StringUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include "Arguments.h"
#include "CLIUtils.h"
#include <algorithm>
#include <cctype>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>
 
static inline const std::unordered_map<std::string, WriterType> writerTable = {
    {"vtk", WriterType::VTK}, {"xyz", WriterType::XYZ}, {"nil", WriterType::NIL}};
 
static inline const std::unordered_map<std::string, SimulationType> simulationTable = {
    {"gravity", SimulationType::GRAVITY}, {"lj", SimulationType::LJ}};
 
static inline const std::unordered_map<std::string, ParallelizationType> parallelizationTable = {
    {"coarse", ParallelizationType::COARSE}, {"fine", ParallelizationType::FINE}};
 
static inline const std::unordered_map<WriterType, std::string> writerStringTable = []() {
    std::unordered_map<WriterType, std::string> reverseMap;
    for (const auto &pair : writerTable)
        reverseMap[pair.second] = pair.first;
    return reverseMap;
}();
 
static inline const std::unordered_map<SimulationType, std::string> simulationStringTable = []() {
    std::unordered_map<SimulationType, std::string> reverseMap;
    for (const auto &pair : simulationTable)
        reverseMap[pair.second] = pair.first;
    return reverseMap;
}();
 
static inline const std::unordered_map<ParallelizationType, std::string> parallelizationStringTable = []() {
    std::unordered_map<ParallelizationType, std::string> reverseMap;
    for (const auto &pair : parallelizationTable)
        reverseMap[pair.second] = pair.first;
    return reverseMap;
}();
 
static inline bool findStringIC(const std::string &haystack, const std::string &needle) {
    auto it = std::search(haystack.begin(), haystack.end(), needle.begin(), needle.end(),
                          [](unsigned char ch1, unsigned char ch2) { return std::toupper(ch1) == std::toupper(ch2); });
    return (it != haystack.end());
}
 
namespace StringUtils {
static inline double toDouble(const std::string &str) {
    try {
        // invalidate NAN, INF and hex numbers
        if (findStringIC(str, "inf") || findStringIC(str, "nan") || findStringIC(str, "0x"))
            throw std::invalid_argument("Invalid number");
 
        // convert singular passed number as string
        size_t idx = 0;
        double converted = std::stod(str, &idx);
        if (idx != str.length())
            throw std::invalid_argument("Invalid number");
        return converted;
    } catch (const std::invalid_argument &ia) {
        CLIUtils::error("Could not convert to decimal", str);
    } catch (const std::out_of_range &oor) {
        CLIUtils::error("Number out of conversion range", str);
    }
    // shouldn't reach this; only here to "mute" compiler warning
    return 0.0;
}
 
static inline double toInt(const std::string &str) {
    try {
        size_t idx = 0;
        int converted = std::stoi(str, &idx);
        if (idx != str.length())
            throw std::invalid_argument("Invalid number");
        return converted;
    } catch (const std::invalid_argument &ia) {
        CLIUtils::error("Could not convert to integer", str);
    } catch (const std::out_of_range &oor) {
        CLIUtils::error("Number out of conversion range", str);
    }
    // shouldn't reach this; only here to "mute" compiler warning
    return 0;
}
 
template <size_t N> static inline std::array<int, N> toIntArray(const std::string &str) {
    if (str.empty() || N == 0)
        return {};
 
    if (str.front() != '{' || str.back() != '}')
        CLIUtils::error("Invalid array syntax", str);
 
    std::array<int, N> arr = {};
    std::string tmp;
    std::string numbers = str.substr(1, str.size() - 2);
    std::stringstream ss(numbers);
 
    size_t i = 0;
    while (i < N && std::getline(ss, tmp, ',')) {
        arr[i++] = StringUtils::toInt(tmp);
    }
 
    return arr;
}
 
template <size_t N> static inline std::array<double, N> toDoubleArray(const std::string &str, bool reqBrackets = true) {
    if (str.empty() || N == 0)
        return {};
 
    if (reqBrackets && (str.front() != '{' || str.back() != '}'))
        CLIUtils::error("Invalid array syntax", str);
 
    std::array<double, N> arr = {};
    std::string tmp;
    std::string numbers = reqBrackets ? str.substr(1, str.size() - 2) : str;
    std::stringstream ss(numbers);
 
    size_t i = 0;
    while (i < N && std::getline(ss, tmp, ',')) {
        arr[i++] = StringUtils::toDouble(tmp);
    }
 
    return arr;
}
 
static inline WriterType toWriterType(const std::string &type) {
    auto it = writerTable.find(type);
    if (it != writerTable.end())
        return it->second;
    else
        CLIUtils::error("Invalid output type", type);
    return WriterType::VTK; // shouldn't reach this; included to silence warning
}
 
static inline SimulationType toSimulationType(const std::string &type) {
    auto it = simulationTable.find(type);
    if (it != simulationTable.end())
        return it->second;
    else
        CLIUtils::error("Invalid output type", type);
    return SimulationType::GRAVITY; // shouldn't reach this; included to silence warning
}
 
static inline ParallelizationType toParallelizationType(const std::string &type) {
    auto it = parallelizationTable.find(type);
    if (it != parallelizationTable.end())
        return it->second;
    else
        CLIUtils::error("Invalid output type", type);
    return ParallelizationType::COARSE; // shouldn't reach this; included to silence warning
}
 
static inline std::string fromChar(char c) {
    std::string s{c};
    return s;
}
 
static inline std::string fromWriterType(WriterType writerType) { return writerStringTable.at(writerType); }
 
static inline std::string fromSimulationType(SimulationType simulationType) {
    return simulationStringTable.at(simulationType);
}
 
static inline std::string fromParallelizationType(ParallelizationType parallelizationType) {
    return parallelizationStringTable.at(parallelizationType);
}
 
template <typename T> std::string static inline fromNumber(T number) { return std::to_string(number); }
 
template <typename T> static inline std::string fromVector(const std::vector<T> &vec) {
    std::stringstream ss;
    ss << "[";
    for (size_t i = 0; i < vec.size(); ++i) {
        ss << vec[i];
        if (i != vec.size() - 1)
            ss << ", ";
    }
    ss << "]";
    return ss.str();
}
 
} // namespace StringUtils