stringUtils.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UTILS_STRINGUTILS_HPP_
#define IV_SRC_UTILS_STRINGUTILS_HPP_
 
#include "core/concepts.hpp"
#include "core/exception.hpp"
 
#include <algorithm>
#include <array>
#include <charconv>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <ranges>
#include <string_view>
#include <vector>
 
namespace iv::utils
{
 
std::string stringJoin(const std::vector<std::string> &strings, char delim);
 
uint32_t stringToIpv4(std::string_view ipStr);
 
std::string ipv4ToString(uint32_t ipAddr);
 
bool hostWildcardMatch(std::string_view issued_, std::string_view host_);
 
template<typename CharT1, typename CharT2>
inline int32_t compareSubstring(const CharT1 *str1, const CharT2 *str2, std::size_t length)
    requires std::convertible_to<CharT1, char> && std::convertible_to<CharT2, char>
{
    if (str1 == nullptr || str2 == nullptr)
    {
        throw std::invalid_argument("Null pointer argument");
    }
 
    std::basic_string<CharT1> string1(str1);
    std::basic_string<CharT2> string2(str2);
 
    if (length > string1.size() || length > string2.size())
    {
        throw std::invalid_argument("Length exceeds string size");
    }
 
    return string1.compare(0, length, string2, 0, length);
}
 
template<typename StringType>
inline void appendToString(std::string *strResult, StringType str)
    requires std::convertible_to<StringType, const char *>
{
    if (strResult == nullptr)
    {
        throw std::invalid_argument("strResult pointer is nullptr");
    }
 
    if (str == nullptr)
    {
        throw std::invalid_argument("str pointer is nullptr");
    }
 
    strResult->append(str);
}
 
template<typename StringType, typename DelimiterType>
std::vector<StringType> splitOn(const StringType &str, const DelimiterType &delim)
    requires std::is_convertible_v<StringType, std::string> ||
             (std::is_convertible_v<StringType, std::string_view> &&
              (std::is_convertible_v<DelimiterType, std::string> ||
               std::is_same_v<DelimiterType, typename StringType::value_type>) )
{
    if constexpr (std::is_same_v<DelimiterType, typename StringType::value_type>)
    {
        if (str.empty())
        {
            return {str};
        }
    }
    else
    {
        if constexpr (std::is_class_v<DelimiterType>)
        {
            if (delim.empty())
            {
                throw std::invalid_argument("Delimiter cannot be empty");
            }
        }
        else
        {
            if (delim == 0)
            {
                return {str};
            }
        }
    }
 
    std::vector<StringType> elems {};
    size_t pos {0};
    size_t found;
 
    while ((found = str.find(delim, pos)) != StringType::npos)
    {
        elems.push_back(str.substr(pos, found - pos));
 
        if constexpr (std::is_class_v<DelimiterType>)
        {
            pos = found + delim.size();
        }
        else
        {
            pos = found + 1;
        }
    }
 
    elems.push_back(str.substr(pos));
    return elems;
}
 
template<typename StringType>
std::string truncate(const StringType &str, size_t length, bool show_ellipsis = true)
    requires std::is_convertible_v<StringType, std::string> or std::is_convertible_v<StringType, std::string_view>
{
    if (str.size() <= length)
    {
        return str;
    }
 
    if (show_ellipsis)
    {
        return str.substr(0, length - 3) + "...";
    }
 
    return str.substr(0, length);
}
 
template<iv::concepts::StringRepresentable T1, iv::concepts::StringRepresentable T2>
bool isEqualStringsCaseInsensitive(const T1 &str1, const T2 &str2)
{
    std::string_view sv1;
    std::string_view sv2;
 
    if constexpr (std::same_as<T1, char>)
    {
        sv1 = std::string_view(&str1, 1);
    }
    else if constexpr (std::same_as<T1, std::vector<char>>)
    {
        sv1 = std::string_view(str1.data(), str1.size());
    }
    else
    {
        sv1 = str1;
    }
 
    if constexpr (std::same_as<T2, char>)
    {
        sv2 = std::string_view(&str2, 1);
    }
    else if constexpr (std::same_as<T2, std::vector<char>>)
    {
        sv2 = std::string_view(str2.data(), str2.size());
    }
    else
    {
        sv2 = str2;
    }
 
    if (sv1.size() != sv2.size())
    {
        return false;
    }
 
    return std::equal(sv1.begin(), sv1.end(), sv2.begin(),
                      [](char a, char b) { return std::tolower(a) == std::tolower(b); });
}
 
template<iv::concepts::StringRepresentable T1, iv::concepts::StringRepresentable T2>
bool isEqual(const T1 &str1, const T2 &str2)
{
    std::string_view sv1;
    std::string_view sv2;
 
    if constexpr (std::same_as<T1, char>)
    {
        sv1 = std::string_view(&str1, 1);
    }
    else if constexpr (std::same_as<T1, std::vector<char>>)
    {
        sv1 = std::string_view(str1.data(), str1.size());
    }
    else
    {
        sv1 = str1;
    }
 
    if constexpr (std::same_as<T2, char>)
    {
        sv2 = std::string_view(&str2, 1);
    }
    else if constexpr (std::same_as<T2, std::vector<char>>)
    {
        sv2 = std::string_view(str2.data(), str2.size());
    }
    else
    {
        sv2 = str2;
    }
 
    return sv1.compare(sv2) == 0;
}
 
inline void replaceSubString(std::string &source, const std::string &strToSearch, const std::string &strToReplace)
{
    size_t pos = 0;
    while ((pos = source.find(strToSearch, pos)) != std::string::npos)
    {
        source.replace(pos, strToSearch.length(), strToReplace);
        pos += strToReplace.length();
    }
}
 
inline void replaceChar(std::string *str, char charSearching, char charToChange)
{
    std::replace(str->begin(), str->end(), charSearching, charToChange);
}
 
inline std::string createWithInitialization(char car, uint64_t numChars)
{
    return std::string(numChars, car);
}
 
std::optional<size_t> findCharacterInString(std::string_view str, char car);
 
inline bool isAlphaNumericCharacter(char car)
{
    std::locale loc;
    return std::isalnum(car, loc);
}
 
inline bool isAlphabeticCharacter(char car)
{
    std::locale loc;
    return std::isalpha(car, loc);
}
 
inline bool isSpecialRealNumberCharacter(char car)
{
    static constexpr std::string_view validChars {".-"};
    return validChars.contains(car);
}
 
inline bool isSpecialIntegerCharacter(char car)
{
    static constexpr std::string_view validChars {"-"};
    return validChars.contains(car);
}
 
inline bool isDigitCharacter(char car)
{
    return std::isdigit(car);
}
 
inline bool isValidRealNumberCharacter(char car)
{
    return isDigitCharacter(car) or isSpecialRealNumberCharacter(car);
}
 
inline bool isValidIntegerCharacter(char car)
{
    return isDigitCharacter(car) or isSpecialIntegerCharacter(car);
}
 
inline bool isHexadecimalCharacter(char car)
{
    const char *validChars = "0123456789abcdefABCDEF";
    return std::strchr(validChars, car) != nullptr;
}
 
bool isHexadecimalString(const std::string &str);
 
uint8_t calculateDecimalDigits(std::string_view str);
 
uint8_t calculateDecimalDigits(double precision);
 
template<typename T>
std::string formatNumber(T number, std::optional<uint8_t> precision = std::nullopt)
    requires iv::concepts::IntegerType<T> || iv::concepts::FloatingPointType<T>
{
    try
    {
        std::ostringstream out;
 
        if constexpr (iv::concepts::FloatingPointType<T>)
        {
            uint8_t decimalDigits {precision.value_or(calculateDecimalDigits(number))};
            if (not precision.has_value() and decimalDigits == 0)
            {
                decimalDigits = 1;
            }
            out << std::fixed << std::setprecision(decimalDigits) << number;
        }
        else
        {
            if constexpr (std::is_same_v<T, int8_t> or std::is_same_v<T, uint8_t>)
            {
                out << static_cast<int32_t>(number);
            }
            else
            {
                out << number;
            }
        }
 
        const auto strValue = out.str();
        return strValue == "-0" ? "0" : strValue;
    }
    catch (const std::exception &e)
    {
        throw iv::exception::InvalidArgument("Error converting number to string: {}", e.what());
    }
}
 
std::string demangle(const std::type_info &ti);
 
std::string iso88591_to_utf8(std::string_view input);
 
}// namespace iv::utils
 
#endif//IV_SRC_UTILS_STRINGUTILS_HPP_