CepsString.cpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS 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.
 
   CEPS 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 CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "common/toolbox/CepsString.hpp"
#include "common/core/CepsIoMacros.hpp"
#include "common/containers/CepsVector.hpp"
 
#include <dirent.h>
 
CepsVector<CepsString>
ceps::split(const CepsString& s, const CepsString& delimiters)
{
  return splitUntilNthDelimiter(s, static_cast<CepsUInt>(-1), delimiters);
}
 
CepsMap<CepsString, CepsVector<CepsString>>
ceps::split(const CepsMap<CepsString,CepsString>& map, const CepsString& delimiters)
{
  CepsMap<CepsString,CepsVector<CepsString>> res = {};
  for (auto [k,v] : map)
    res.insert(std::make_pair(k, split(v, delimiters)));
  return res;
}
 
CepsVector<CepsVector<CepsString>>
ceps::split(const CepsVector<CepsString>& vec, const CepsString& delimiters)
{
  CepsVector<CepsVector<CepsString>> res = {};
  res.reserve(vec.size());
  for (auto s : vec)
    res.push_back(split(s, delimiters));
  return res;
}
 
CepsString
ceps::join(const CepsVector<CepsString>& vec, const CepsChar& delimeter)
{
  CepsVector<CepsString> clean = ceps::cleanup(vec);
  CepsString out = "";
  const CepsUInt& n = clean.size();
  for (CepsUInt i = 0; i < n; ++i)
  {
    out += clean[i];
    if (i < n-1)
      out += delimeter;
  }
  return out;
}
 
CepsString
ceps::trim(const CepsString& s)
{
  size_t     posBegin = s.find_first_not_of(" \t");
  size_t     posEnd   = s.find_last_not_of (" \t")+1;
  CepsString str      = (posEnd>posBegin) ? s.substr(posBegin,posEnd-posBegin) : CepsString("");
  return str;
}
 
CepsString
ceps::removeSpaces(const CepsString& s)
{
  CepsString str = s;
  str.erase(std::remove_if(str.begin(),str.end(),isspace), str.end());
  return str;
}
 
CepsString
ceps::substract(const CepsString& s, const CepsString& toErase)
{
  CepsString out = s;
  size_t pos = out.find(toErase);
  while (pos != CepsString::npos)
  {
    out.erase(pos, toErase.length());
    pos = out.find(toErase);
  }
  return out;
}
 
CepsString
ceps::substract(const CepsString& s, const CepsVector<CepsString>& toErase)
{
  CepsString out = s;
  for (CepsString e : toErase)
  {
    size_t pos = out.find(e);
    while (pos != CepsString::npos)
    {
      out.erase(pos, e.length());
      pos = out.find(e);
    }
  }
  return out;
}
 
CepsString
ceps::toUpper(const CepsString& s)
{
  CepsString str = s;
 
  for (char& c : str)
    c = toupper(c);
  return str;
}
 
CepsString
ceps::toLower(const CepsString& s)
{
  CepsString str = s;
 
  for (auto& c : str)
    c = tolower(c);
  return str;
}
 
CepsBool
ceps::isPathInOneWord(const CepsString &s)
{
  CepsVector<CepsString> words = split(s, " ");
 
  // If there is only one word,
  // this loop does not exist
  for (uint i=0U; i<words.size()-1; i++)
    if (not words[i].ends_with ("\\"))
      return false;
  return true;
}
 
CepsString
ceps::toKey(const CepsString& s)
{
  CepsString str = s;
 
  str.erase(std::remove(str.begin(),str.end(),'"'),str.end());
  str = toUpper(str);
  str = removeSpaces(str);
  return str;
}
 
CepsVector<CepsString>
ceps::toKey(const CepsVector<CepsString>& vec)
{
  CepsVector<CepsString> out = {};
  out.reserve(vec.size());
  for (auto& s : vec)
    out.push_back(ceps::toKey(s));
  return out;
}
 
void
ceps::toKeyInPlace(CepsVector<CepsString>& vec)
{
  for (auto& s : vec)
    s = ceps::toKey(s);
  return;
}
 
CepsBool
ceps::toBool(const CepsString& s)
{
  CepsString val = toKey(s);
  return (val == "YES" or val == "TRUE" or val == "1" or val == "ON");
}
 
CepsReal
ceps::toReal(const CepsString &s)
{
  try
  {
    return (CepsReal) std::stod(trim(s));
  }
  catch (...)
  {
    CEPS_ABORT("Cannot convert \"" << s << "\" into a real number");
    return 0x0;
  }
}
 
CepsSet<CepsReal>
ceps::toReals(const CepsString &s)
{
  auto l                = split(s);
  CepsSet<CepsReal> out = {};
 
  for (auto ss: l)
    out.insert(toReal(ss));
    
  return out;
}
 
CepsMathScalar
ceps::toMathScalar(const CepsVector<CepsString>& vec)
{
  CEPS_ABORT_IF(vec.size() not_eq 1,"vector must be of size 1");
  CepsMathScalar value = ceps::toReal (vec[0]);
  return value;
}
 
CepsMathVertex
ceps::toMathVertex(const CepsVector<CepsString>& vec)
{
  CEPS_ABORT_IF(vec.size () not_eq 3,"vector must be of size 3");
  CepsMathVertex value;
  for (CepsUInt i = 0U; i < 3; ++i)
    value(i) = ceps::toReal(vec[i]);
  return value;
}
 
CepsMathTensor
ceps::toMathTensor(const CepsVector<CepsString>& vec)
{
  CepsMathTensor value = CepsMathTensor::Zero();
  if (vec.size()==1)
    for (CepsUInt i = 0U; i < 3; ++i)
      value(i,i) = ceps::toReal(vec[0]);
  else if (vec.size()==3)
    for (CepsUInt i = 0U; i < 3; ++i)
      value(i,i) = ceps::toReal(vec[i]);
  else if (vec.size()==6) // Symmetric
  {
    value(0,0) = ceps::toReal(vec[0]);
    value(0,1) = ceps::toReal(vec[1]);
    value(0,2) = ceps::toReal(vec[2]);
    value(1,0) = ceps::toReal(vec[1]);
    value(1,1) = ceps::toReal(vec[3]);
    value(1,2) = ceps::toReal(vec[4]);
    value(2,0) = ceps::toReal(vec[2]);
    value(2,1) = ceps::toReal(vec[4]);
    value(2,2) = ceps::toReal(vec[5]);
  }
  else if (vec.size()==9)
  {
    for (CepsUInt i = 0U; i < 3; ++i)
      for (CepsUInt j = 0U; j < 3; ++j)
        value (i,j) = ceps::toReal(vec[i*3+j]);
  }
  else
    CEPS_ABORT("vector must be of size 1, 3, 6 or 9");
  return value;
}
 
CepsInt
ceps::toInt(const CepsString& s)
{
  try
  {
    return (CepsInt) std::stoi(trim(s));
  }
  catch(...)
  {
    CEPS_ABORT("cannot convert \"" << s << "\" into an integer");
    return 0x0;
  }
}
 
CepsSet<CepsInt>
ceps::toInts(const CepsString& s)
{
  auto             l    = split(s);
  CepsSet<CepsInt> out  = {};
 
  for (auto ss: l)
    out.insert(toInt(ss));
 
  return out;
}
 
CepsUInt
ceps::toUInt(const CepsString& s)
{
  try
  {
    return (CepsUInt) std::stoi(trim(s));
  }
  catch(...)
  {
    CEPS_ABORT ("Cannot convert \"" << s << "\" into an unsigned integer");
    return 0x0;
  }
}
 
CepsSet<CepsUInt>
ceps::toUInts(const CepsString& s)
{
  auto              l   = split(s);
  CepsSet<CepsUInt> out = {};
 
  for (auto ss : l)
    out.insert(toUInt(ss));
    
  return out;
}
 
CepsBool
ceps::isNumber(const CepsString& s)
{
  try 
  {
    std::stod(trim(s));
    return true;
  }
  catch (...)
  {
  }
  return false;
 
  // const CepsString& other = trim(s);
  // std::string::const_iterator it = other.begin ();
  // while (it != other.end () and (std::isdigit (*it) or std::isspace(*it)))
  //   ++it;
  // return not other.empty () and it == other.end ();
}
 
CepsBool
ceps::startsWith(const CepsString& s, const CepsString& comp)
{
  std::size_t n_str  = s   .length();
  std::size_t n_comp = comp.length();
  if (n_str >= n_comp)
    return (0 == s.compare(0,n_comp,comp));
 
  return false;
}
 
CepsBool
ceps::startsWithOneOf(const CepsString& s, const CepsVector<CepsString>& comps)
{
  for (const CepsString& comp : comps)
    if (startsWith(s,comp))
      return true;
 
  return false;
}
 
CepsBool
ceps::endsWith(const CepsString& s, const CepsString& comp)
{
  std::size_t n_str  = s   .length();
  std::size_t n_comp = comp.length();
  if (n_str >= n_comp)
    return (0 == s.compare (n_str - n_comp, n_comp, comp));
 
  return false;
}
 
CepsBool
ceps::endsWithOneOf(const CepsString& s, const CepsVector<CepsString>& comps)
{
  for (const CepsString &comp : comps)
    if (endsWith (s, comp))
      return true;
 
  return false;
}
 
CepsMap<CepsString, CepsVector<CepsString>>
ceps::splitByKeyword(const CepsString& s, const CepsSet<CepsString>& tags)
{
  CepsMap<CepsString, CepsVector<CepsString>> res = {};
 
  // Prepare tags and split input string
  std::set<CepsString> TAGS = {};
  for (CepsString tag: tags)
    TAGS.insert (toKey(tag));
 
  CepsVector<CepsString> vec = split(s);
 
  CepsString             currentKey = "", word;
  CepsVector<CepsString> currentWords;
 
  for (uint wpos = 0U; wpos < vec.size(); wpos++)
  {
    word = toKey(vec[wpos]);
    if (TAGS.contains(word))
    {
      if (not currentKey.empty())
        res[currentKey] = currentWords;
      currentKey = word;
      currentWords.clear();
    }
    else
      currentWords.push_back(vec[wpos]);
  }
  // Put last read key into map
  if (not currentKey.empty())
    res[currentKey] = currentWords;
 
  return res;
}
 
CepsVector<CepsString>
ceps::splitAtNthDelimiter(
  const CepsString &s,
  CepsUInt   n,
  CepsString delimiters
)
{
  CepsVector<CepsString> res(2);
  CepsVector<CepsString> words = split(s,delimiters);
  CepsArray2<CepsVector<CepsString>> swords;
  CepsUInt i,nw=words.size();
 
  for (i=0;i<std::min(n,nw);i++)
    swords[0].push_back(words[i]);
  for (;i<nw;i++)
    swords[1].push_back(words[i]);
  CepsChar delim(delimiters[0]);
  res[0] = join(swords[0],delim);
  res[1] = join(swords[1],delim);
  return res;
}
 
CepsVector<CepsString>
ceps::splitUntilNthDelimiter(
  const CepsString &s,
  const CepsUInt   &n,
  CepsString        delimiters
)
{
  CepsVector<CepsString>  elements = {};
  CepsUInt                counter  = 0;
 
  if (s.length() != 0)
  {
    CepsString s2 = trim(s);
    size_t     posBegin;
    // Build a string of non space delimiters
    // (that can be occuring several times, e.g:
    // " data1 ,,, data4, ...  "
    CepsString delims2(delimiters);
    delims2.erase(std::remove(delims2.begin(),delims2.end(),' ' ),delims2.end());
    delims2.erase(std::remove(delims2.begin(),delims2.end(),'\t'),delims2.end());
 
    // CepsString starting with delimiters...
    if (delimiters.find(s2.front()) != delimiters.npos)
      elements.push_back("");
 
    posBegin = s2.find_first_not_of(delimiters.c_str());
 
    while ((posBegin!=s2.npos) and (counter!=n))
    {
      size_t posEnd = s2.find_first_of(delimiters.c_str(), posBegin);
      if (posEnd > posBegin)
        elements.push_back(trim(s2.substr(posBegin, posEnd-posBegin)));
      posBegin = s2.find_first_not_of(delimiters.c_str(), posEnd);
 
      // In case there was several successive non space delimiters
      if (posBegin != s2.npos)
        for (size_t posT = posEnd + 1; posT < posBegin; posT++)
          if (delims2.find(s2[posT]) != delims2.npos)
            elements.push_back("");
 
      counter++;
    }
    
    // CepsString ending with a delimiter...
    if (delimiters.find(s2.back()) != delimiters.npos)
      elements.push_back("");
 
    // we stoped because of counter
    if (posBegin != s2.npos)
      elements.push_back(trim(s2.substr(posBegin,s2.size())));
  }
 
  return cleanup(elements);
}
 
CepsString
ceps::readParams(
  const CepsVector<CepsString>& scope,
  const CepsString&             tag,
  const CepsString&             def,
  const CepsUInt&               pad
)
{
  auto it = std::find(scope.begin(),scope.end(),tag);
  if (it + pad < scope.end())
    return *(it+pad);
  return def;
}
 
CepsString
ceps::removeDoubleSlashes(const CepsString& path)
{
  CepsVector<CepsString> words = split(path,"/");
  CepsVector<CepsString> clean;
  for (CepsString word:words)
    if (not word.empty())
      clean.push_back(word);
  return join(clean,'/');
}
 
CepsString
ceps::getDir(const CepsString &s)
{
  // Get execution directory
  CepsString pwd;
  CepsChar*   buf = nullptr; 
  CepsChar*  path = realpath(".", buf);
  free(buf);
  pwd = CepsString(path) + "/";
  free(path);
 
  // if there is a / in the filename
  if (s.find('/')!=s.npos)
  {
    // Remove end from string
    CepsString res = s.substr(0,s.find_last_of('/')+1);
    // Transform relative to absolute paths
    // ./foo
    if (startsWith(s,"./"))
      res.replace(0,2,pwd);
    // ../bar
    else if (startsWith(s,"../"))
    {
      pwd.pop_back();
      CEPS_ABORT_IF(pwd.size()==0,
        "ceps::getDir: trying to access parent directory from / "
      );
      pwd = pwd.substr(0,pwd.find_last_of('/')+1);
      res.replace (0,3,pwd);
    }
    return res;
  }
  return pwd;
}
 
CepsString
ceps::getFilename(const CepsString& s)
{
  CepsUInt last = s.find_last_of("/\\");
  return (s.substr(last + 1));
}
 
CepsString
ceps::getBaseName(const CepsString& fileName)
{
  size_t firstChar, lastDot, lastSlash;
  lastSlash = fileName.find_last_of('/');
  if (lastSlash != fileName.npos)
    firstChar = lastSlash + 1;
  else
    firstChar = 0;
  lastDot = fileName.find_last_of('.');
  if (lastDot > firstChar)
    return fileName.substr(firstChar, lastDot - firstChar);
  if (lastDot < lastSlash)
    return fileName.substr(firstChar, fileName.npos);
  return CepsString("");
}
 
CepsString
ceps::getExtension(const CepsString& s)
{
  CepsInt lastDot   = s.find_last_of('.');
  CepsInt lastSlash = s.find_last_of('/');
  return (lastDot > lastSlash) ? (s.substr(lastDot+1)) : "";
}
 
CepsString
ceps::changeExtension(const CepsString& s, const CepsString& ext)
{
  return getDir(s) + getBaseName(s) + "." + ext;
}
 
// WARNING: This may not be cross-platform !!
CepsBool
ceps::fileExists(const CepsString& fileName, const CepsString& directory)
{
 
  // Remove the directory from the file name if it was given
  CepsString cutFile = ceps::getBaseName(fileName);
  if (not ceps::getExtension(fileName).empty())
    cutFile += "." + ceps::getExtension(fileName);
 
  // Open specified directory
  DIR *dir = opendir (directory.c_str());
  if (ceps::isNullPtr(dir))
  {
    // std::cerr<<"CepsIo: unable to open directory \'"<<directory.c_str()<<"\'"<<endl;
    return false;
    // exit(EXIT_FAILURE);
  }
  // The file structure
  struct dirent *dp;
 
  // While there are files to read
  while ((dp = readdir(dir)) != nullptr)
  {
    CepsString file(dp->d_name);
    if (cutFile.compare(file) == 0)
    {
      // We found the file
      closedir(dir);
      return true;
    }
  }
  // Not found
  closedir(dir);
  return false;
}
 
CepsBool
ceps::fileExists(const CepsString& fileName)
{
  return ceps::fileExists(fileName,ceps::getDir(fileName));
}
 
CepsBool
ceps::isSameFile(const CepsString& f1, const CepsString& f2)
{
 
  CepsString ff1 = ceps::getDir(f1)+"/"+ceps::getFilename(f1);
  CepsString ff2 = ceps::getDir(f2)+"/"+ceps::getFilename(f2);
 
  return ceps::removeDoubleSlashes(ff1)==ceps::removeDoubleSlashes(ff2);
}
 
CepsVector<CepsString>
ceps::cleanup(const CepsVector<CepsString>& vec)
{
  CepsVector<CepsString> out = vec;
 
  auto f = [] (std::string const &s) { 
    return s.empty() or s==" "; 
  };
 
  out.erase(std::remove_if(out.begin(),out.end(),f),out.end());
 
  return out;
}
 
CepsReal
ceps::readReal(std::istream& file, const CepsString& message)
{
  CepsReal res = 0.;
  try {
    CepsString buf;
    file >> buf;
    res = std::stod(buf);
  } 
  catch (...)
  {
    CEPS_ABORT(message);
  }
  return res;
}
 
CepsInt
ceps::readInt(std::istream& file, const CepsString& message)
{
  CepsInt res = 0.;
  try {
    CepsString buf;
    file >> buf;
    res = std::stoi(buf);
  } 
  catch (...)
  {
    CEPS_ABORT(message);
  }
  return res;
}
 
CepsReal3D
ceps::readVertex(std::istream& file, const CepsString& message)
{
  CepsReal3D res;
  for (CepsUInt i=0;i<3;i++)
  {
    res[i] = readReal(file,message+"("+toString(i)+")");
  }
  return res;
}
 
CepsMathTensor
ceps::readTensor(std::istream& file, const CepsString& message)
{
  CepsMathTensor res;
  for (CepsUInt i=0;i<3;i++)
  for (CepsUInt j=0;j<3;j++)
  {
    res(i,j) = readReal(file,message+"("+toString(i)+","+toString(j)+")");
  }
  return res;
}