stringUtils.tpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit 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 bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_STRING_UTILS_TPP__
#define __BITPIT_STRING_UTILS_TPP__
 
namespace bitpit {
 
namespace utils {
 
namespace string {
 
inline std::string & ltrim(std::string &s)
{
    // The argument of the lambda function passed to the erase method is an
    // unsigned char, that's because, like all other functions from <cctype>,
    // the behavior of std::isspace is undefined if the argument's value is
    // neither representable as unsigned char nor equal to EOF. To use these
    // functions safely, they should not be directly used with standard
    // algorithms when the iterator's value type is char or signed char.
    // Instead, the value should be converted to unsigned char first (see
    // https://en.cppreference.com/w/cpp/string/byte/isspace#Notes).
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char c){ return !std::isspace(c); }));
 
    return s;
}
 
inline std::string &rtrim(std::string &s)
{
    // The argument of the lambda function passed to the erase method is an
    // unsigned char, that's because, like all other functions from <cctype>,
    // the behavior of std::isspace is undefined if the argument's value is
    // neither representable as unsigned char nor equal to EOF. To use these
    // functions safely, they should not be directly used with standard
    // algorithms when the iterator's value type is char or signed char.
    // Instead, the value should be converted to unsigned char first (see
    // https://en.cppreference.com/w/cpp/string/byte/isspace#Notes).
    s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char c){ return !std::isspace(c); }).base(), s.end());
 
    return s;
}
 
inline std::string &trim(std::string &s)
{
    return ltrim(rtrim(s));
}
 
inline std::string lfill(int nchars, const std::string &s, char c)
{
    std::stringstream ss;
    ss << std::string(nchars - s.length(), c) << s;
 
    return ss.str();
}
 
inline std::string rfill(int nchars, const std::string &s, char c)
{
    std::stringstream ss;
    ss << s << std::string(nchars - s.length(), c);
 
    return ss.str();
}
 
inline std::string zeroPadNumber(int nchars, int num)
{
    std::ostringstream ss;
    ss << std::setw(nchars) << std::setfill('0') << num;
 
    return ss.str();
}
 
inline bool keywordInString(const std::string &line, const std::string &key)
{
    return (line.find(key) != std::string::npos);
}
 
template <class T>
void convertString(std::string input, T &output)
{
    trim(input);
    std::stringstream ss(input);
 
    T x;
    std::vector<T> tmp;
    while (ss.good()) {
        ss >> x;
        tmp.push_back(x);
    }
 
    if (tmp.size() == 0) {
        std::cout << " no useful information in string " << input   << std::endl;
        std::cout << " casting zero                   " <<  std::endl;
 
        x = static_cast<T> (0);
    } else if (tmp.size() == 1) {
        x = tmp[0];
    } else if(tmp.size() > 1) {
        std::cout << " more than one element in string " << input   << std::endl;
        std::cout << " assigning first element             "  << std::endl;
 
        x = tmp[0];
    }
 
    output = x;
}
 
template <class T>
void convertString(std::string input, std::vector<T> &output)
{
    output.clear();
 
    trim(input);
    std::stringstream ss(input);
 
    T x;
    std::vector<T> tmp;
    while (ss.good()) {
        ss >> x;
        tmp.push_back(x);
    }
 
    if (tmp.size() == 0) {
        std::cout << " no useful information in string " << input   << std::endl;
        std::cout << " returning void vector          " <<  std::endl;
    };
 
    output = tmp;
}
 
template <class T, size_t n>
void convertString(std::string input, std::array<T,n> &output)
{
    T x;
    std::vector<T> tmp;
 
    tmp.clear();
 
    trim(input);
    std::stringstream ss(input);
 
    while (ss.good()) {
        ss >> x;
        tmp.push_back(x);
    }
 
    if (tmp.size() < n) {
        std::cout << " not enough useful information in string " << input   << std::endl;
        std::cout << " casting zero into missing elements      " <<  std::endl;
 
        x = static_cast<T>(0);
        output.fill(x);
 
        for(size_t i=0; i<tmp.size(); i++) {
            output[i] = tmp[i];
        }
    } else if (tmp.size() == n) {
        for(size_t i = 0; i < n; i++) {
            output[i] = tmp[i];
        }
    } else if (tmp.size() > n) {
        std::cout << " more than " << n << " elements in string " << input   << std::endl;
        std::cout << " assigning first element " << n << " elements "   << std::endl;
 
        for(size_t i = 0; i < n; i++) {
            output[i] = tmp[i];
        }
    }
}
 
}
 
}
 
}
 
#endif