StringUtils.h

Go to the documentation of this file.

/*
 *  This 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
 *  any later version.
 *  The software 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 the software. If not, see <http://www.gnu.org/licenses/>.
 *
 *  Copyright 2017, Kuylen E, Willem L, Broeckhove J
 */

#pragma once

#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <cctype>
#include <iomanip>
#include <sstream>
#include <string>

#include <vector>

namespace stride {
namespace util {

inline bool CheckAllDigits(const std::string& s)
{
        bool status = true;
        for (const auto& e : s) {
                status = (status && isdigit(e));
                if (!status)
                        break;
        }
        return status;
}

template <typename T>
inline T FromString(const std::string& s)
{
        std::stringstream ss(s);
        T                 t;
        ss >> t;
        return t;
}

inline std::vector<std::string> Split(const std::string& s, const std::string& delimiters)
{
        std::vector<std::string> tokens;
        boost::algorithm::split(tokens, s, boost::is_any_of(delimiters));
        return tokens;
}

inline std::vector<std::string> Tokenize(const std::string& str, const std::string& delimiters)
{
        std::vector<std::string> tokens;

        // Skip delimiters at beginning.
        std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
        // Find first non-delimiter.
        std::string::size_type pos = str.find_first_of(delimiters, lastPos);

        while (std::string::npos != pos || std::string::npos != lastPos) {
                // Found a token, add it to the vector.
                tokens.push_back(str.substr(lastPos, pos - lastPos));
                // Skip delimiters.
                lastPos = str.find_first_not_of(delimiters, pos);
                // Find next non-delimiter.
                pos = str.find_first_of(delimiters, lastPos);
        }

        return tokens;
}

template <typename T>
inline std::string ToString(const T& value)
{
        std::stringstream ss;
        ss << value;
        return ss.str();
}

template <>
inline std::string ToString<std::string>(const std::string& value)
{
        return value;
}

template <typename It>
inline std::vector<std::string> ToString(
    typename std::enable_if<!std::is_same<typename It::value_type, std::string>::value, It>::type first, It last)
{
        std::vector<std::string> v;
        for (It it = first; it < last; ++it) {
                v.emplace_back(ToString(*it));
        }
        return v;
}

template <typename It>
inline std::vector<std::string> ToString(
    typename std::enable_if<std::is_same<typename It::value_type, std::string>::value, It>::type first, It last)
{
        std::vector<std::string> v;
        std::copy(first, last, back_inserter(v));
        return v;
}

template <typename T>
inline std::string ToString(const T& value, int width, char fill = ' ')
{
        std::stringstream ss;
        ss << std::setw(width) << std::setfill(fill) << value;
        return ss.str();
}

inline std::string ToLower(const std::string& source)
{
        auto        lower = [](int c) -> int { return std::tolower(c); };
        std::string copy;
        std::transform(source.begin(), source.end(), std::back_inserter(copy), lower);
        return copy;
}

inline std::string ToUpper(const std::string& source)
{
        auto        upper = [](int c) -> int { return std::toupper(c); };
        std::string copy;
        std::transform(source.begin(), source.end(), std::back_inserter(copy), upper);
        return copy;
}

inline std::string TrimRight(const std::string& source, const std::string& t = " ")
{
        std::string str = source;
        return str.erase(str.find_last_not_of(t) + 1);
}

inline std::string TrimLeft(const std::string& source, const std::string& t = " ")
{
        std::string str = source;
        return str.erase(0, source.find_first_not_of(t));
}

inline std::string Trim(const std::string& source, const std::string& t = " ")
{
        return TrimLeft(TrimRight(source, t), t);
}

template <typename T>
inline std::string intToDottedString(const T& value)
{
        std::string valueStr = std::to_string(value);

        std::string res;
        std::size_t rest = valueStr.length() % 3;

        res += valueStr.substr(0, rest);

        for (size_t i = rest; i < valueStr.length(); i += 3) {
                res += "." + valueStr.substr(i, 3);
        }

        if (res[0] == '.') {
                return res.substr(1);
        }

        return res;
}

} // namespace util
} // namespace stride