strings.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CORE_STRINGS_HPP_
#define IV_SRC_CORE_STRINGS_HPP_
 
#include "core/exception.hpp"
 
#include <algorithm>
#include <array>
#include <iomanip>
#include <string>
#include <vector>
 
namespace iv::strings
{
 
void replaceSubString(std::string &source, const std::string &strToSearch, const std::string &strToReplace);
 
template<typename StringType>
 void toUpper(StringType &str)
    requires(std::is_convertible_v<StringType, std::string> ||
             std::is_same_v<std::remove_pointer_t<std::decay_t<StringType>>, char> ||
             (std::is_same_v<std::decay_t<StringType>, std::string> &&
              std::is_same_v<typename std::decay_t<StringType>::value_type, char>) ||
             (std::is_same_v<std::decay_t<StringType>, std::vector<char>>) ||
             (std::is_same_v<std::decay_t<StringType>,
                             std::array<char, std::tuple_size_v<std::decay_t<StringType>>>>) )
{
    std::transform(str.begin(), str.end(), str.begin(), [](const unsigned char c) { return std::toupper(c); });
}
 
template<typename StringType>
 void toLower(StringType &str)
    requires(std::is_convertible_v<StringType, std::string> ||
             std::is_same_v<std::remove_pointer_t<std::decay_t<StringType>>, char> ||
             (std::is_same_v<std::decay_t<StringType>, std::string> &&
              std::is_same_v<typename std::decay_t<StringType>::value_type, char>) ||
             (std::is_same_v<std::decay_t<StringType>, std::vector<char>>) ||
             (std::is_same_v<std::decay_t<StringType>,
                             std::array<char, std::tuple_size_v<std::decay_t<StringType>>>>) )
{
    std::transform(str.begin(), str.end(), str.begin(), [](const unsigned char c) { return std::tolower(c); });
}
 
std::string utf8ToAscii(const std::string &utf8str);
 
void trim(std::string &str);
 
void ltrim(std::string &str);
 
void rtrim(std::string &str);
 
uint32_t toU32bit(std::string_view str);
 
uint16_t toUint16(std::string_view str);
 
std::vector<std::string> parseAlgorithmName(std::string_view in);
 
std::string fromBool(bool value, std::string_view trueString = "On", std::string_view falseString = "Off");
 
template<typename T>
std::string bytesToHex(const T &data, const bool reverseOption = false)
    requires std::ranges::sized_range<T> || std::is_array_v<T>
{
    if constexpr (not std::ranges::sized_range<T> && not std::is_array_v<T>)
    {
        throw iv::exception::InvalidArgument("Input must be a sized range or array.");
    }
 
    size_t length {0};
 
    if constexpr (std::ranges::sized_range<T>)
    {
        length = std::size(data);
    }
    else if constexpr (std::is_array_v<T>)
    {
        length = std::extent_v<T>;
    }
 
    if (length == 0)
    {
        throw std::invalid_argument("Input range or array is empty.");
    }
 
    std::ostringstream oss;
 
    for (size_t i = 0; i < length; i++)
    {
        size_t index = reverseOption ? length - 1 - i : i;
        const auto value = static_cast<unsigned char>(data[index]);
        oss << std::setw(2) << std::setfill('0') << std::hex << std::uppercase << static_cast<int32_t>(value);
 
        if (i != length - 1)
        {
            oss << "-";
        }
    }
 
    return oss.str();
}
 
// Specialization for void*
std::string bytesToHex(const void *data, size_t length, bool reverseOption = false);
 
}// namespace iv::strings
 
#endif//IV_SRC_CORE_STRINGS_HPP_