StringUtils.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <random>
#include <span>
#include <sstream>
#include <string>
#include <vector>
 
namespace tgbotxx {
  namespace StringUtils {
    template<typename T, typename D>
    [[nodiscard]] static std::string join(std::span<T> con, const D& delim) {
      std::ostringstream oss{};
      auto it = con.begin();
      if (it == con.end()) {
        return {};
      }
      oss << *it;
      ++it;
      for (; it != con.end(); ++it) {
        oss << delim << *it;
      }
      return oss.str();
    }
    template<typename T, typename D>
    [[nodiscard]] static std::string join(const std::vector<T>& con, const D& delim) {
      return join(std::span{con}, delim);
    }
 
    [[nodiscard]] static std::vector<std::string> split(const std::string& str, char delim) {
      std::vector<std::string> res;
      std::stringstream ss{str};
      std::string chunk;
      while (std::getline(ss, chunk, delim))
        res.push_back(chunk);
      return res;
    }
 
    [[nodiscard]] static std::string toLowerCopy(std::string str) {
      std::transform(str.begin(), str.end(), str.begin(), ::tolower);
      return str;
    }
 
    static void toLower(std::string& str) {
      std::transform(str.begin(), str.end(), str.begin(), ::tolower);
    }
 
    [[nodiscard]] static std::string toUpperCopy(std::string str) {
      std::transform(str.begin(), str.end(), str.begin(), ::toupper);
      return str;
    }
 
    static void toUpper(std::string& str) {
      std::transform(str.begin(), str.end(), str.begin(), ::toupper);
    }
 
    static void ltrim(std::string& str) {
      str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](unsigned char ch) {
                  return !std::isspace(ch);
                }));
    }
 
    static void rtrim(std::string& str) {
      str.erase(std::find_if(str.rbegin(), str.rend(), [](unsigned char ch) {
                  return !std::isspace(ch);
                }).base(),
                str.end());
    }
 
 
    static void trim(std::string& str) {
      rtrim(str);
      ltrim(str);
    }
 
    [[nodiscard]] static std::string ltrimCopy(std::string s) {
      ltrim(s);
      return s;
    }
 
    [[nodiscard]] static std::string rtrimCopy(std::string s) {
      rtrim(s);
      return s;
    }
 
    [[nodiscard]] static std::string trimCopy(std::string s) {
      trim(s);
      return s;
    }
 
    [[nodiscard]] static bool startsWith(const std::string& str, const std::string& prefix, bool ignoreCase = false) {
      if (str.size() < prefix.size()) return false;
      if (ignoreCase)
        return std::equal(prefix.begin(), prefix.end(), str.begin(),
                          [](char a, char b) { return std::tolower(a) == std::tolower(b); });
      return str.compare(0, prefix.size(), prefix) == 0;
    }
 
    [[nodiscard]] static bool endsWith(const std::string& str, const std::string& suffix, bool ignoreCase = false) {
      if (str.size() < suffix.size()) return false;
      if (ignoreCase)
        return std::equal(suffix.begin(), suffix.end(), str.begin() + str.size() - suffix.size(),
                          [](char a, char b) { return std::tolower(a) == std::tolower(b); });
      return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
    }
 
    static void replace(std::string& str, const std::string& search, const std::string& replace) {
      if (search.empty()) return; // Avoid infinite loops
      std::size_t pos{0};
      while ((pos = str.find(search, pos)) != std::string::npos) {
        str.replace(pos, search.length(), replace);
        pos += replace.length();
      }
    }
 
 
    [[nodiscard]] static std::string replaceCopy(std::string str, const std::string& search, const std::string& replace) {
      if (search.empty()) return str; // Avoid infinite loops
      std::size_t pos{0};
      while ((pos = str.find(search, pos)) != std::string::npos) {
        str.replace(pos, search.length(), replace);
        pos += replace.length();
      }
      return str;
    }
 
    template<typename T>
    [[nodiscard]] static T to(const std::string& str) {
      T v{};
      std::istringstream oss{str};
      oss >> v;
      return v;
    }
 
    [[nodiscard]] static std::string random(std::size_t length) {
      static std::random_device seed{};
      static std::default_random_engine engine{seed()};
      static std::uniform_int_distribution<short> choice(0, 2);
      static std::uniform_int_distribution<int> lowercaseAlpha('a', 'z');
      static std::uniform_int_distribution<int> uppercaseAlpha('A', 'Z');
      static std::uniform_int_distribution<int> digits('0', '9');
 
      std::string str(length, '\000');
      for (char& c: str) {
        switch (choice(engine)) {
          case 0: // a-z
            c = static_cast<char>(lowercaseAlpha(engine));
            break;
          case 1: // A-Z
            c = static_cast<char>(uppercaseAlpha(engine));
            break;
          case 2: // 0-9
            c = static_cast<char>(digits(engine));
            break;
          default:
            break;
        }
      }
      return str;
    }
  };
}