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(const std::string &input, T &output)
{
    std::size_t nValues = 0;
    std::stringstream ss(input);
    ss >> std::ws;
    while (ss.good()) {
        ++nValues;
        if (nValues > 1) {
            std::cout << " more than one element in string " << input   << std::endl;
            std::cout << " assigning first element             "  << std::endl;
            return;
        }
 
        ss >> output;
        ss >> std::ws;
    }
 
    if (nValues == 0) {
        std::cout << " no useful information in string " << input   << std::endl;
        std::cout << " casting zero                   " <<  std::endl;
 
        output = T{};
    }
}

template <class T>
void convertString(const std::string &input, std::vector<T> &output)
{
    output.clear();
 
    std::stringstream ss(input);
    ss >> std::ws;
    while (ss.good()) {
        T x;
        ss >> x;
        ss >> std::ws;
        output.push_back(std::move(x));
    }
 
    if (output.empty()) {
        std::cout << " no useful information in string " << input   << std::endl;
        std::cout << " returning empty vector          " <<  std::endl;
    };
}

template <class T, size_t n>
void convertString(const std::string &input, std::array<T,n> &output)
{
    std::size_t nValues = 0;
    std::stringstream ss(input);
    ss >> std::ws;
    while (ss.good()) {
        ++nValues;
        if (nValues > n) {
            std::cout << " more than " << n << " elements in string " << input   << std::endl;
            std::cout << " assigning first " << n << " elements "   << std::endl;
            return;
        }
 
        ss >> output[nValues - 1];
        ss >> std::ws;
    }
 
    if (nValues < n) {
        std::cout << " not enough useful information in string " << input   << std::endl;
        std::cout << " casting zero into missing elements      " <<  std::endl;
 
        for(size_t i=nValues; i<n; i++) {
            output[i] = T{};
        }
    }
}
 
}
 
}
 
}
 
#endif