StringLine.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  MURE 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 Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _STRINGLINE_
#define _STRINGLINE_
 
#include <string>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cctype>
#include <locale>
 
using namespace std;
 
class StringLine
{
  public:
 
    static string NextWord(string Line, int &start, char sep = ' ', char alt_sep = '\0');
 
    static string PreviousWord(string Line, int &start, char sep = ' ', char alt_sep = '\0');
 
    static int GetStartWord(string Line, int CurrentPosition, char sep = ' ');
 
    static int GetEndWord(string Line, int CurrentPosition, char sep = ' ');
 
    static string ReplaceAll(string InLine, string ToReplace, string By);
 
 
    static void ltrim(std::string &s);
 
    static void rtrim(std::string &s);
 
    static void trim(std::string &s);
 
 
 
    static int Find(const char *search, string Line);
 
    static int rFind(const char *search, string Line);
 
    static void ToLower(string &Line); 
    static void ToUpper(string &Line); 
 
 
    template < class out_T, class in_T > static  out_T convert(const in_T  &t);
 
    template < class T > static bool ToNumber(T &t, const std::string &s, std::ios_base & (*f)(std::ios_base & ))
    {
        if(s.size() == 0) return true;
        std::istringstream iss(s);
        return ! (iss >> f >> t).fail();
    }
    static bool IsDouble(const std::string &s);
};
 
 
//_________________________________________________________________________________
inline string StringLine::NextWord(string Line, int &start, char sep, char alt_sep)
{
    string Word = "";
    if(start >= int(Line.size()))
    {
        return Word;
    }
    if(alt_sep != '\0') //replace all alt_sep by sep
    {
        string ToReplace = string(1, alt_sep); //cast char to string using constructor
        string By = string(1, sep);
        Line = ReplaceAll(Line, ToReplace, By);
    }
 
    start = GetStartWord(Line, start, sep);
    int wordlength = GetEndWord(Line, start, sep) - start;
 
    Word = Line.substr(start, wordlength);
 
    start += wordlength;
    return Word;
}
//_________________________________________________________________________________
inline string StringLine::PreviousWord(string Line, int &start, char sep, char alt_sep)
{
    string Word = "";
    if(start <= 0)
    {
        return Word;
    }
    if(start >= int(Line.size())) //first valid pos should be the 1st end char
        start = Line.size() - 1;
    if(alt_sep != '\0') //replace all alt_sep by sep
    {
        string ToReplace = string(1, alt_sep); //cast char to string using constructor
        string By = string(1, sep);
        Line = ReplaceAll(Line, ToReplace, By);
    }
    while(Line[start] == sep) //suppress end sep
        start--;
    int pos = Line.rfind(sep, start);
    int wordlength = start - Line.rfind(sep, pos);
 
    if(pos <= 0)
    {
        Word = Line.substr(0, start + 1);
        start = 0;
        return Word;
    }
    Word = Line.substr(pos + 1, wordlength);
 
    start -= wordlength + 1;
    return Word;
}
 
//_________________________________________________________________________________
inline void StringLine::ltrim(std::string &s)
{
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch)
    {
        return ! std::iswspace(ch);
    }));
}
 
//_________________________________________________________________________________
inline void StringLine::rtrim(std::string &s)
{
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch)
    {
        return ! std::iswspace(ch);
    }).base(), s.end());
}
 
//_________________________________________________________________________________
inline void StringLine::trim(std::string &s)
{
    ltrim(s);
    rtrim(s);
}
 
//_________________________________________________________________________________
inline void StringLine::ToLower(string &Line)
{
    transform (Line.begin(), Line.end(),    // source
               Line.begin(),                // destination
               (int(*)(int))tolower);       // operation
}
 
//_________________________________________________________________________________
inline void StringLine::ToUpper(string &Line)
{
    transform (Line.begin(), Line.end(),    // source
               Line.begin(),                // destination
               (int(*)(int))toupper);       // operation
}
 
//_________________________________________________________________________________
inline int StringLine::GetStartWord(string Line, int CurrentPosition, char sep)
{
    int pos = Line.find(sep, CurrentPosition);
    if(pos == int(string::npos)) return CurrentPosition;
    while(CurrentPosition < int(Line.size()) && Line[CurrentPosition] == sep)
        CurrentPosition++;
    return CurrentPosition;
}
 
//_________________________________________________________________________________
inline int StringLine::GetEndWord(string Line, int CurrentPosition, char sep)
{
    int pos = Line.find(sep, CurrentPosition);
 
    if(pos == int(string::npos))
        return Line.size();
    return pos;
}
 
//_________________________________________________________________________________
inline int StringLine::Find(const char *search, string Line)
{
    size_t Pos = Line.find(search);
    if(Pos != string::npos ) return Pos;
    return -1;
}
 
//_________________________________________________________________________________
inline int StringLine::rFind(const char *search, string Line)
{
    size_t Pos = Line.rfind(search);
    if(Pos != string::npos) return Pos;
    return -1;
}
 
//_________________________________________________________________________________
template < class out_T, class in_T >
inline out_T StringLine::convert(const in_T  &t)
{
    stringstream stream;
    stream << t;        // insert value to stream
    out_T result;       // store conversion's result here
    stream >> result;   // write value to result
    return result;
}
 
//_________________________________________________________________________________
inline string StringLine::ReplaceAll(string InLine, string ToReplace, string By)
{
    if(ToReplace == By) return InLine;
    int start = 0;
    int pos = InLine.find(ToReplace, start);
    while(pos != int(string::npos))
    {
        InLine.replace(pos, ToReplace.size(), By);
        start = 0;
        pos = InLine.find(ToReplace, start);
    }
    return InLine;
}
//_________________________________________________________________________________
inline bool StringLine::IsDouble(const std::string &s)
{
    std::istringstream i(s);
    double temp;
    return ( (i >> temp) ? true : false );
}
 
#endif