StringUtils.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright © 2014-2024 Allan Leal
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// C++ includes
#include <functional>
#include <sstream>
#include <string>
#include <vector>
#include <variant>
 
namespace Reaktoro {
namespace internal {
 
template<typename T>
auto operator<<(std::ostream& out, std::vector<T> const& values) -> std::ostream&
{
    for(auto i = 0; i < values.size(); ++i)
        out << ((i == 0) ? "" : ", ") << values[i];
    return out;
}
 
template <typename Arg>
auto stringfy(std::ostringstream& ss, std::string const& sep, Arg const& item) -> void
{
    ss << item;
}
 
template <typename Arg, typename... Args>
auto stringfy(std::ostringstream& ss, std::string const& sep, Arg const& item, Args... items) -> void
{
    ss << item << sep;
    stringfy(ss, sep, items...);
}
 
} // namespace internal
 
template <typename... Args>
auto stringfy(std::string const& sep, Args... items) -> std::string
{
    std::ostringstream ss;
    internal::stringfy(ss, sep, items...);
    return ss.str();
}
 
template <typename... Args>
auto stringfy(std::variant<Args...> const& var) -> std::string
{
    std::ostringstream ss;
    std::visit([&](auto arg){ ss << arg; }, var);
    return ss.str();
}
 
template <typename... Args>
auto str(Args... items) -> std::string
{
    return stringfy("", items...);
}
 
auto precision(int precision) -> void;
 
auto precision() -> int;
 
auto strfix(double num, int precision = -1) -> std::string;
 
auto strsci(double num, int precision = -1) -> std::string;
 
auto replace(std::string original, std::string substr, std::string newsubstr) -> std::string;
 
auto lowercase(std::string str) -> std::string;
 
auto uppercase(std::string str) -> std::string;
 
auto trimleft(std::string str) -> std::string;
 
auto trimright(std::string str) -> std::string;
 
auto trim(std::string str) -> std::string;
 
auto split(std::string const& str, std::string const& delims, std::function<std::string(std::string)> transform) -> std::vector<std::string>;
 
auto split(std::string const& str, std::string const& delims = " ") -> std::vector<std::string>;
 
auto join(std::vector<std::string> const& strs, std::string sep = " ") -> std::string;
 
auto tofloat(std::string const& str) -> double;
 
auto makeunique(std::vector<std::string> words, std::string suffix) -> std::vector<std::string>;
 
auto strlength(std::string const& str) -> std::size_t;
 
auto strlength(const char* str) -> std::size_t;
 
template<typename SubStr, typename... SubStrs>
auto startswith(std::string const& str, SubStr substr, SubStrs... substrs)
{
    auto const aux = str.find(substr) == 0;
    if constexpr(sizeof...(SubStrs) > 0)
        return aux || startswith(str, substrs...);
    return aux;
}
 
template<typename SubStr, typename... SubStrs>
auto endswith(std::string const& str, SubStr substr, SubStrs... substrs)
{
    auto const aux = str.rfind(substr) == str.size() - strlength(substr);
    if constexpr(sizeof...(SubStrs) > 0)
        return aux || endswith(str, substrs...);
    return aux;
}
 
} // namespace Reaktoro