str.h

Go to the documentation of this file.

 
#ifndef HERMES_COMMON_STR_H
#define HERMES_COMMON_STR_H
 
#include <string>
#include <sstream>
#include <vector>
#include <regex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <cstring>
#include <cstdint>
#include <hermes/common/defs.h>
#include <hermes/common/str_view.h>
 
namespace hermes {
 
// *********************************************************************************************************************
//                                                                                                                Str
// *********************************************************************************************************************
class Str {
public:
  // *******************************************************************************************************************
  //                                                                                                    STATIC FIELDS
  // *******************************************************************************************************************
  struct regex {
    static const char floating_point_number[];
    static const char integer_number[];
    static const char alpha_numeric_word[];
    static const char c_identifier[];
    //                                                                                                            regex
    static bool match(const std::string &s, const std::string &pattern,
                      std::regex_constants::match_flag_type flags = std::regex_constants::match_default);
    static bool contains(const std::string &s, const std::string &pattern,
                         std::regex_constants::match_flag_type flags = std::regex_constants::match_default);
    static std::smatch search(const std::string &s, const std::string &pattern,
                              std::regex_constants::match_flag_type flags = std::regex_constants::match_default);
    static bool search(std::string s,
                       const std::string &pattern,
                       const std::function<void(const std::smatch &)> &callback,
                       std::regex_constants::match_flag_type flags = std::regex_constants::match_default);
    static std::string replace(const std::string &s, const std::string &pattern, const std::string &format,
                               std::regex_constants::match_flag_type flags = std::regex_constants::match_default);
  };
  // *******************************************************************************************************************
  //                                                                                                   STATIC METHODS
  // *******************************************************************************************************************
  //                                                                                                          queries
  static bool isPrefix(const std::string& p, const std::string& s);
  //                                                                                                       formatting
  static std::string abbreviate(const std::string &s, size_t width, const char fmt[4] = "s.s");
  template<typename T>
  static std::string rjust(const T &value, size_t width, char fill_char = ' ') {
    Str s;
    s = s << value;
    if (s.str().size() >= width)
      return s.str();
    return std::string(width - s.str().size(), fill_char) + s.str();
  }
  template<typename T>
  static std::string ljust(const T &value, size_t width, char fill_char = ' ') {
    Str s;
    s = s << value;
    if (s.str().size() >= width)
      return s.str();
    return s.str() + std::string(width - s.str().size(), fill_char);
  }
  template<typename T>
  static std::string cjust(const T &value, size_t width, char fill_char = ' ') {
    Str s;
    s = s << value;
    if (s.str().size() >= width)
      return s.str();
    size_t pad = (width - s.str().size()) / 2;
    return std::string(pad, fill_char) + s.str() + std::string(pad, fill_char);
  }
  template<typename... Ts>
  static std::string format(const std::string &fmt, Ts &&... args) {
    std::stringstream s;
    std::string r;
    if constexpr(sizeof...(args) > 0) {
      format_r_(s, fmt, 0, std::forward<Ts>(args) ...);
      r = s.str();
    } else
      r = fmt;
    return r;
  }
  template<typename T>
  static std::string toHex(T i, bool leading_zeros = false, bool zero_x = false) {
    std::stringstream stream;
    if (zero_x)
      stream << "0x";
    if (leading_zeros)
      stream << std::setfill('0') << std::setw(sizeof(T) * 2)
             << std::hex << i;
    else
      stream << std::hex << i;
    if (!i)
      stream << '0';
    return stream.str();
  }
  static std::string strip(const std::string &s, const std::string &patterns = " \t\n");
  //                                                                                                   concatenation
  template<class... Args>
  static std::string concat(const Args &... args) {
    std::stringstream s;
    (s << ... << args);
    return s.str();
  }
  static std::string join(const std::vector<std::string> &v, const std::string &separator = "");
  template<typename T>
  static std::string join(const std::vector<T> &v, const std::string &separator = "") {
    bool first = true;
    std::stringstream r;
    for (const auto &s : v) {
      if (!first)
        r << separator;
      first = false;
      r << s;
    }
    return r.str();
  }
  //                                                                                                       separation
  static std::vector<std::string> split(const std::string &s,
                                        const std::string &delimiters = " ");
  //                                                                                                          numeric
  static std::string printBits(u32 n) {
    std::string r;
    for (int i = 31; i >= 0; i--)
      if ((1 << i) & n)
        r += '1';
      else
        r += '0';
    return r;
  }
  template<typename T>
  static std::string binaryToHex(T input_n, bool uppercase = true, bool strip_leading_zeros = false) {
    static const char digits[] = "0123456789abcdef";
    static const char DIGITS[] = "0123456789ABCDEF";
    unsigned long long n = 0;
    std::memcpy(&n, &input_n, sizeof(T));
    std::string s;
    for (int i = sizeof(T) - 1; i >= 0; --i) {
      u8 a = n >> (8 * i + 4) & 0xf;
      u8 b = (n >> (8 * i)) & 0xf;
      if (a)
        strip_leading_zeros = false;
      if (!strip_leading_zeros)
        s += (uppercase) ? DIGITS[a] : digits[a];
      if (b)
        strip_leading_zeros = false;
      if (!strip_leading_zeros)
        s += (uppercase) ? DIGITS[b] : digits[b];
    }
    return s;
  }
  static std::string addressOf(uintptr_t ptr, u32 digit_count = 8) {
    std::string s;
    // TODO: assuming little endianess
    for (i8 i = 7; i >= 0; --i) {
      auto h = binaryToHex((ptr >> (i * 8)) & 0xff, true);
      s += h.substr(h.size() - 2);
    }
    return "0x" + s.substr(s.size() - digit_count, digit_count);
  }
  static std::string byteToBinary(byte b) {
    std::string s;
    for (int i = 7; i >= 0; i--)
      s += std::to_string((b >> i) & 1);
    return s;
  }
  static bool isInteger(const std::string &s);
  static bool isNumber(const std::string &s);
  // *******************************************************************************************************************
  //                                                                                                 FRIEND FUNCTIONS
  // *******************************************************************************************************************
  inline friend Str operator<<(const char *s, const Str &str) {
    return {str.str() + s};
  }
  inline friend Str operator+(const std::string &s, const Str &str) {
    std::stringstream ss;
    ss << s << str.s_;
    return {ss.str()};
  }
  //                                                                                                          boolean
  inline friend bool operator==(const char *ss, const Str &s) {
    return s.str() == ss;
  }
  template<typename T>
  inline bool friend operator==(const T &t, const Str &s) {
    std::stringstream ss;
    ss << t;
    return s.str() == ss.str();
  }
  // *******************************************************************************************************************
  //                                                                                                     CONSTRUCTORS
  // *******************************************************************************************************************
  Str();
  Str(std::string s);
  Str(const char *s);
  Str(const Str &other);
  Str(Str &&other) noexcept;
  ~Str();
  // *******************************************************************************************************************
  //                                                                                                           ACCESS
  // *******************************************************************************************************************
  [[nodiscard]] inline const std::string &str() const { return s_; }
  [[nodiscard]] inline const char *c_str() const { return s_.c_str(); }
  [[nodiscard]] inline size_t size() const { return s_.size(); }
  [[nodiscard]] inline bool empty() const { return s_.empty(); }
  Result<ConstStrView> substr(size_t pos = 0, i64 len = -1);
  // *******************************************************************************************************************
  //                                                                                                          METHODS
  // *******************************************************************************************************************
  template<class... Args>
  void append(const Args &... args) {
    std::ostringstream s;
    (s << ... << args);
    s_ += s.str();
  }
  template<class... Args>
  void appendLine(const Args &... args) {
    std::ostringstream s;
    (s << ... << args);
    s_ += s.str() + '\n';
  }
  // *******************************************************************************************************************
  //                                                                                                        OPERATORS
  // *******************************************************************************************************************
  //                                                                                                       assignment
  Str &operator=(const Str &s) = default;
  template<typename T>
  Str &operator=(const T &t) {
    std::stringstream ss;
    ss << t;
    s_ = ss.str();
    return *this;
  }
  //                                                                                                       arithmetic
  Str &operator+=(const Str &other) {
    s_ += other.s_;
    return *this;
  }
  template<typename T>
  Str &operator+=(const T &t) {
    std::stringstream ss;
    ss << t;
    s_ += ss.str();
    return *this;
  }
  template<typename T>
  inline Str operator+(const T &t) const {
    std::stringstream ss;
    ss << s_ << t;
    return ss.str();
  }
  inline Str operator<<(const char *s) const {
    return {s_ + s};
  }
  //                                                                                                          boolean
  inline bool operator==(const char *ss) const {
    return s_ == ss;
  }
  template<typename T>
  inline bool operator==(const T &t) const {
    std::stringstream ss;
    ss << t;
    return s_ == ss.str();
  }
private:
  // *******************************************************************************************************************
  //                                                                                                  PRIVATE METHODS
  // *******************************************************************************************************************
  template<typename T>
  static void format_r_(std::stringstream &s, const std::string &fmt, u32 i, const T &first) {
    auto first_i = i;
    while (i + 1 < fmt.size() && !(fmt[i] == '{' && fmt[i + 1] == '}'))
      ++i;
    if (i + 1 < fmt.size()) {
      s << fmt.substr(first_i, i - first_i);
      s << first;
      s << fmt.substr(i + 2, fmt.size() - i - 2);
    } else
      s << fmt.substr(first_i, fmt.size() - first_i);
  }
  template<typename T, typename...Ts>
  static void format_r_(std::stringstream &s, const std::string &fmt, u32 i, const T &first, Ts &&... rest) {
    // iterate until first occurrence of pair {}
    auto first_i = i;
    while (i + 1 < fmt.size() && !(fmt[i] == '{' && fmt[i + 1] == '}'))
      ++i;
    if (i + 1 < fmt.size()) {
      s << fmt.substr(first_i, i - first_i);
      s << first;
      if constexpr(sizeof ...(rest) > 0)
        format_r_(s, fmt, i + 2, std::forward<Ts>(rest)...);
      else
        s << fmt.substr(i + 2, fmt.size() - i - 2);
    } else
      s << fmt.substr(first_i, fmt.size() - first_i);
  }
  // *******************************************************************************************************************
  //                                                                                                   PRIVATE FIELDS
  // *******************************************************************************************************************
  std::string s_;
};
 
// *********************************************************************************************************************
//                                                                                                                 IO
// *********************************************************************************************************************
inline std::ostream &operator<<(std::ostream &os, const Str &s) {
  os << s.str();
  return os;
}
template<typename T>
inline Str operator<<(const Str &s, T t) {
  std::stringstream ss;
  ss << t;
  return {s + ss.str()};
}
template<typename T, std::enable_if_t<std::is_same_v<T, std::string> == false>>
inline Str operator<<(T t, const Str &s) {
  std::stringstream ss;
  ss << t;
  return {s + ss.str()};
}
 
}
 
#endif //HERMES_COMMON_STR_H