String.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <iomanip>
#include <locale>
#include <sstream>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
 
namespace volcart
{
 
static inline void to_upper(std::string& s)
{
    const auto& f = std::use_facet<std::ctype<char>>(std::locale());
    f.toupper(s.data(), s.data() + s.size());
}
 
static inline std::string to_upper(std::string&& s)
{
    to_upper(s);
    return s;
}
 
static inline std::string to_upper_copy(std::string s)
{
    to_upper(s);
    return s;
}
 
static inline void to_lower(std::string& s)
{
    const auto& f = std::use_facet<std::ctype<char>>(std::locale());
    f.tolower(s.data(), s.data() + s.size());
}
 
static inline std::string to_lower(std::string&& s)
{
    to_lower(s);
    return s;
}
 
static inline std::string to_lower_copy(std::string s)
{
    to_lower(s);
    return s;
}
 
static inline auto to_bool(const std::string& s) -> bool
{
    bool b{false};
    if (s.size() == 1) {
        std::stringstream(s) >> b;
    } else if (s.size() > 1) {
        std::stringstream(s) >> std::boolalpha >> b;
    }
    return b;
}
 
static inline void trim_left(std::string& s)
{
    const auto& loc = std::locale();
    s.erase(s.begin(), std::find_if_not(s.begin(), s.end(), [&loc](auto ch) {
                return std::isspace(ch, loc);
            }));
}
 
static inline std::string trim_left(std::string&& s)
{
    trim_left(s);
    return s;
}
 
static inline std::string trim_left_copy(std::string s)
{
    trim_left(s);
    return s;
}
 
static inline void trim_right(std::string& s)
{
    const auto& loc = std::locale();
    s.erase(
        std::find_if_not(
            s.rbegin(), s.rend(),
            [&loc](auto ch) { return std::isspace(ch, loc); })
            .base(),
        s.end());
}
 
static inline std::string trim_right(std::string&& s)
{
    trim_right(s);
    return s;
}
 
static inline std::string trim_right_copy(std::string s)
{
    trim_right(s);
    return s;
}
 
static inline void trim(std::string& s)
{
    trim_left(s);
    trim_right(s);
}
 
static inline std::string trim(std::string&& s)
{
    trim(s);
    return s;
}
 
static inline std::string trim_copy(std::string s)
{
    trim(s);
    return s;
}
 
template <typename... Ds>
static inline std::vector<std::string> split(
    const std::string& s, const Ds&... ds)
{
    // Build delimiters list
    std::vector<char> delims;
    if (sizeof...(ds)) {
        delims = {ds...};
    } else {
        delims.emplace_back(' ');
    }
 
    // Get a list of all delimiter start positions
    std::vector<std::string::size_type> delimPos;
    for (const auto& delim : delims) {
        auto b = s.find(delim, 0);
        while (b != std::string::npos) {
            delimPos.emplace_back(b);
            b = s.find(delim, b + 1);
        }
    }
 
    // Sort the delimiter start positions
    std::sort(delimPos.begin(), delimPos.end());
 
    // Split string
    std::vector<std::string> tokens;
    std::string::size_type begin{0};
    for (std::size_t it = 0; it < delimPos.size(); it++) {
        auto end = delimPos[it];
        auto t = s.substr(begin, end - begin);
        if (not t.empty()) {
            tokens.emplace_back(t);
        }
        begin = end + 1;
    }
    auto t = s.substr(begin);
    if (not t.empty()) {
        tokens.emplace_back(t);
    }
 
    return tokens;
}
 
static inline auto partition(std::string_view s, std::string_view sep)
    -> std::tuple<std::string, std::string, std::string>
{
    // Find the starting position
    const auto startPos = s.find(sep);
 
    // Didn't find the delimiter
    if (startPos == std::string::npos) {
        return {std::string(s), "", ""};
    }
 
    // Split into parts
    auto pre = std::string(s.substr(0, startPos));
    auto mid = std::string(s.substr(startPos, sep.size()));
    auto post = std::string(s.substr(startPos + sep.size()));
 
    // Return the parts
    return {pre, mid, post};
}
 
template <
    typename Integer,
    std::enable_if_t<std::is_integral_v<Integer>, bool> = true>
auto to_padded_string(Integer val, const int padding, const char fill = '0')
    -> std::string
{
    std::stringstream stream;
    stream << std::setw(padding) << std::setfill(fill) << val;
    return stream.str();
}
 
}  // namespace volcart