ah-string-utils.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef AH_STRING_UTILS_H
# define AH_STRING_UTILS_H
 
# include <algorithm>
# include <array>
# include <cctype>
# include <cerrno>
# include <cmath>
# include <cstdlib>
# include <iomanip>
# include <limits>
# include <stdexcept>
# include <string_view>
# include <type_traits>
# include <cstring>
# include <memory>
# include <string>
# include <sstream>
# include <iterator>
# include <vector>
# include <htlist.H>
# include <tpl_array.H>
# include <ah-zip.H>
 
namespace Aleph
{
  template <typename T>
  std::string to_string(const std::vector<T> & v)
  {
    std::ostringstream s;
    for (size_t i = 0; i < v.size(); ++i)
      {
        s << v[i];
        if (i < v.size() - 1)
          s << ", ";
      }
    return s.str();
  }
 
  template <typename T>
  std::string to_string(const Array<T> & v)
  {
    std::ostringstream s;
    for (auto it = v.get_it(); it.has_curr(); it.next_ne())
      {
        s << it.get_curr();
        if (not it.is_last())
          s << ", ";
      }
    return s.str();
  }
 
  // left trim
  inline void ltrim(std::string & s)
  {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
                                    [](const unsigned char ch)
                                      {
                                        return not std::isspace(ch);
                                      }));
  }
 
  // trim from end
  inline void rtrim(std::string & s)
  {
    s.erase(std::find_if(s.rbegin(), s.rend(),
                         [](const unsigned char ch)
                           {
                             return not std::isspace(ch);
                           }).base(), s.end());
  }
 
  namespace concat_detail
  {
    template <typename T>
    inline constexpr bool is_string_like =
      std::is_convertible_v<T, std::string_view> or
      std::is_same_v<std::decay_t<T>, char>;
 
    inline size_t piece_size(std::string_view s) noexcept { return s.size(); }
    inline size_t piece_size(char) noexcept { return 1; }
 
    inline void append_to(std::string & out, std::string_view s) { out += s; }
    inline void append_to(std::string & out, char c) { out += c; }
 
    template <typename T>
    std::string stringify(const T & v)
    {
      if constexpr (std::is_convertible_v<T, std::string_view>)
        return std::string(std::string_view(v));
      else if constexpr (std::is_same_v<std::decay_t<T>, char>)
        return std::string(1, v);
      else if constexpr (std::is_arithmetic_v<std::decay_t<T>>)
        return std::to_string(v);
      else
        {
          std::ostringstream s;
          s << v;
          return s.str();
        }
    }
  } // namespace concat_detail
 
  template <class... Args>
  inline std::string concat(const Args &... args)
  {
    if constexpr (sizeof...(Args) == 0)
      return {};
    else if constexpr ((concat_detail::is_string_like<Args> and ...))
      {
        std::string result;
        result.reserve((concat_detail::piece_size(args) + ...));
        (concat_detail::append_to(result, args), ...);
        return result;
      }
    else
      {
        std::array<std::string, sizeof...(Args)> pieces = {
          concat_detail::stringify(args)...
        };
        size_t total = 0;
        for (const auto & p : pieces)
          total += p.size();
        std::string result;
        result.reserve(total);
        for (const auto & p : pieces)
          result += p;
        return result;
      }
  }
 
  // trim from both ends (in place)
  inline std::string trim(const std::string & s)
  {
    std::string ret = s;
    ltrim(ret);
    rtrim(ret);
    return ret;
  }
 
  inline std::string &trim_in_place(std::string & s)
  {
    ltrim(s);
    rtrim(s);
    return s;
  }
 
  inline bool contains(const std::string_view & str, const std::string_view & substr)
  {
    return str.find(substr) != std::string::npos;
  }
 
  inline std::string to_string(const double d, const size_t precision)
  {
    std::ostringstream s;
    s.precision(precision);
    s << std::fixed << d;
    return s.str();
  }
 
  inline std::string to_str(const double d)
  {
    return to_string(d, std::numeric_limits<double>::max_digits10);
  }
 
  inline std::string tolower(const char *str)
  {
    std::string ret;
    for (const char *ptr = str; *ptr; ++ptr)
      ret.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(*ptr))));
    return ret;
  }
 
  inline std::string toupper(const char *str)
  {
    std::string ret;
    for (const char *ptr = str; *ptr; ++ptr)
      ret.push_back(static_cast<char>(std::toupper(static_cast<unsigned char>(*ptr))));
    return ret;
  }
 
  inline std::string tolower(const std::string & str)
  {
    return tolower(str.c_str());
  }
 
  inline std::string toupper(const std::string & str)
  {
    return toupper(str.c_str());
  }
 
  inline std::string &mutable_tolower(std::string & str)
  {
    for (auto & c: str)
      c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
    return str;
  }
 
  inline std::string &mutable_toupper(std::string & str)
  {
    for (auto & c: str)
      c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
    return str;
  }
 
  inline std::string only_alpha(const std::string & str)
  {
    std::string ret;
    ret.reserve(str.size() + 1);
    for (const char c: str)
      switch (c)
        {
        case '0'...'9':
        case 'a'...'z':
          ret.push_back(c);
          break;
        case 'A'...'Z':
          ret.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
          break;
        default:
          break;
        }
 
    return ret;
  }
 
  inline std::string remove_spaces(const std::string & str)
  {
    const size_t n = str.size();
    std::string ret;
    ret.reserve(n + 1);
    for (const auto c: str)
      if (not std::isspace(static_cast<unsigned char>(c)))
        ret.push_back(c);
    return ret;
  }
 
  inline std::string remove_symbols(const std::string & str, const std::string & symbols)
  {
    const size_t n = str.size();
    std::string ret;
    ret.reserve(n + 1);
    for (const auto c: str)
      if (symbols.find(c) == std::string::npos)
        ret.push_back(c);
 
    return ret;
  }
 
  template <class C>
  inline std::ostream &join(const C & c, const std::string & sep, std::ostream & out)
  {
    if (c.is_empty())
      return out;
 
    auto & last = c.get_last();
    for (auto it = c.get_it(); it.has_curr(); it.next_ne())
      {
        auto & curr = it.get_curr();
        out << curr;
        if (&curr != &last)
          out << sep;
      }
    return out;
  }
 
  template <class C>
  inline std::string join(const C & c, const std::string & sep = " ")
  {
    std::ostringstream s;
    join(c, sep, s);
    return s.str();
  }
 
  // return true if str can be converted to a double
  inline bool is_double(const std::string & str)
  {
    const char *begin = str.c_str();
    char *endptr = nullptr;
    errno = 0;
    const auto val = std::strtod(begin, &endptr);
    if (endptr == begin or *endptr != '\0')
      return false;
    return errno != ERANGE and std::isfinite(val);
  }
 
  inline bool is_float(const std::string & str)
  {
    const char *begin = str.c_str();
    char *endptr = nullptr;
    errno = 0;
    const auto val = std::strtof(begin, &endptr);
    if (endptr == begin or *endptr != '\0')
      return false;
    return errno != ERANGE and std::isfinite(val);
  }
 
  inline bool is_long(const std::string & str)
  {
    const char *begin = str.c_str();
    char *endptr = nullptr;
    errno = 0;
    (void) std::strtol(begin, &endptr, 10);
    if (endptr == begin or *endptr != '\0')
      return false;
    return errno != ERANGE;
  }
 
  inline bool is_size_t(const std::string & str)
  {
    if (str.empty() or str[0] == '-')
      return false;
 
    const char *begin = str.c_str();
    char *endptr = nullptr;
    errno = 0;
    const auto val = std::strtoull(begin, &endptr, 10);
    if (endptr == begin or *endptr != '\0')
      return false;
    if (errno == ERANGE)
      return false;
    return val <= std::numeric_limits<size_t>::max();
  }
 
 
  inline long safe_atol(const std::string & s)
  {
    errno = 0;
    char *endptr = nullptr;
    const auto val = std::strtol(s.c_str(), &endptr, 10);
    const bool invalid =
        (errno == ERANGE and (val == LONG_MAX or val == LONG_MIN)) or
        (errno != 0 and val == 0) or
        endptr == s.c_str();
 
    ah_runtime_error_if(invalid) << "invalid std::string for long: " << s;
    return val;
  }
 
  inline double safe_atof(const std::string & s)
  {
    errno = 0;
    char *endptr = nullptr;
    const auto val = std::strtod(s.c_str(), &endptr);
    const bool invalid =
        (errno == ERANGE and (val == HUGE_VAL or val == HUGE_VALF or val == HUGE_VALL)) or
        (errno != 0 and val == 0) or
        endptr == s.c_str() or
        *endptr != '\0' or
        not std::isfinite(val);
 
    ah_runtime_error_if(invalid) << "invalid std::string for double: " << s;
    return val;
  }
 
  inline bool is_prefix(const std::string & str, const std::string & prefix)
  {
    if (str.size() < prefix.size())
      return false;
    return strncmp(str.data(), prefix.data(), prefix.size()) == 0;
  }
 
  inline std::string remove_prefix(std::string & str, const std::string & prefix)
  {
    if (is_prefix(str, prefix))
      str = str.substr(prefix.size());
    return str;
  }
 
  inline std::string to_lower(const std::string & str)
  {
    std::string ret;
    for (const char c: str)
      ret.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
    return ret;
  }
 
  inline std::string to_upper(const std::string & str)
  {
    std::string ret;
    for (const char c: str)
      ret.push_back(static_cast<char>(std::toupper(static_cast<unsigned char>(c))));
    return ret;
  }
 
  inline std::string to_name(const std::string & str)
  {
    if (str.empty())
      return str;
 
    std::string ret;
    ret.push_back(static_cast<char>(std::toupper(static_cast<unsigned char>(str[0]))));
 
    for (size_t i = 1; i < str.size(); ++i)
      ret.push_back(str[i]);
 
    return ret;
  }
 
  inline DynList<std::string> split_camel_case(const char *const str)
  {
    DynList<std::string> ret;
    if (str == nullptr or *str == '\0')
      return ret;
    const char *ptr = str;
    std::string curr(1, *ptr);
    while (*++ptr)
      if (std::isupper(static_cast<unsigned char>(*ptr)))
        {
          ret.append(curr);
          curr = std::string(1, *ptr);
        }
      else
        curr.push_back(*ptr);
 
    if (not curr.empty())
      ret.append(curr);
 
    return ret;
  }
 
  inline DynList<std::string> split_camel_case(const std::string & str)
  {
    return split_camel_case(str.data());
  }
 
  inline void fill_string(std::string & str, char sym)
  {
    for (char & c: str)
      c = sym;
  }
 
  inline std::vector<std::string> &
  split(const std::string & s, const char delim, std::vector<std::string> & elems)
  {
    std::stringstream ss(s);
    std::string item;
    while (getline(ss, item, delim))
      elems.push_back(item);
 
    return elems;
  }
 
  inline std::vector<std::string> split(const std::string & s, const char delim)
  {
    std::vector<std::string> elems;
    split(s, delim, elems);
    return elems;
  }
 
  template <template <typename> class Container = DynList>
  inline Container<std::string> split_string(const std::string & s, const std::string & delim)
  {
    Container<std::string> elems;
    if (s.empty())
      return elems;
 
    if (delim.empty())
      {
        elems.append(s);
        return elems;
      }
 
    char *saveptr = nullptr;
    char **p = &saveptr;
 
    std::string data = s;
    const char *d = delim.data();
    const auto str = data.data();
 
    for (char *token = strtok_r(str, d, p); token;
         token = strtok_r(nullptr, d, p))
      elems.append(token);
 
    return elems;
  }
 
  inline DynList<std::string> split_to_list(const std::string & s,
                                            const std::string & delim)
  {
    return split_string<DynList>(s, delim);
  }
 
  inline std::string to_Pascalcase(const std::string & str)
  {
    DynList<std::string> tokens = split_to_list(str, " _-");
 
    tokens.mutable_for_each([](std::string & token)
                              {
                                token[0] = ::toupper(token[0]);
                              });
 
    return tokens.foldl<std::string>("", [](const std::string & acu, const std::string & token)
                                       {
                                         return acu + token;
                                       });
  }
 
  inline Array<std::string> split_to_array(const std::string & s,
                                           const std::string & delim)
  {
    return split_string<Array>(s, delim);
  }
 
  inline std::pair<std::string, std::string> split_pos(const std::string & str, const size_t pos)
  {
    ah_range_error_if(pos > str.size())
      << "split_pos(" << str << ", " << pos << "): position " << pos
      << " is larger than std::string size " << str.size();
 
 
    const char *ptr = str.data();
    const char *end1 = ptr + pos;
 
    std::string s1;
    while (ptr != end1)
      s1.push_back(*ptr++);
 
    std::string s2;
    while (*ptr)
      s2.push_back(*ptr++);
 
    return {s1, s2};
  }
 
  inline DynList<std::string> split_n(const std::string & str, const size_t n)
  {
    ah_range_error_if(n == 0) << "split_n(): number of parts cannot be 0";
 
    ah_range_error_if(n > str.size())
      << "split_n(" << str << ", " << n << "): number of parts " << n
      << " is larger than std::string size " << str.size();
 
    const size_t sz = str.size() / n;
 
    const char *ptr = str.data();
 
    DynList<std::string> ret;
 
    for (size_t i = 0; i < n; ++i)
      {
        std::string s;
        if (i + 1 == n)
          while (*ptr)
            s.push_back(*ptr++);
        else
          for (size_t k = 0; k < sz and *ptr; ++k)
            s.push_back(*ptr++);
 
        ret.append(s);
      }
 
    return ret;
  }
 
  template <typename T>
  inline DynList<DynList<T>> complete_rows(DynList<DynList<T>> & m)
  {
    size_t max_sz = 0;
    DynList<size_t> sizes =
        m.template maps<size_t>([&max_sz](auto & l)
                                  {
                                    const size_t sz = l.size();
                                    max_sz = std::max(max_sz, sz);
                                    return sz;
                                  });
 
    DynList<DynList<T>> ret;
    for (auto it = zip_it(m, sizes); it.has_curr(); it.next_ne())
      {
        auto t = it.get_curr();
        DynList<T> & l = get<0>(t);
        const size_t sz = get<1>(t);
        const long n = max_sz - sz;
        for (auto i = 0; i < n; ++i)
          l.append(T());
        ret.append(std::move(l));
      }
 
    return ret;
  }
 
  inline DynList<DynList<std::string>>
  format_string(const DynList<size_t> & lens,
                const DynList<DynList<std::string>> & mat)
  {
    return mat.maps<DynList<std::string>>([&lens](const DynList<std::string> & l)
                                            {
                                              return zip(lens, l).template maps<std::string>([](const auto & p)
                                                   {
                                                     const std::string blanks(p.first > p.second.size() ?
                                                                                p.first - p.second.size() :
                                                                                0, ' ');
                                                     return blanks + p.second + " ";
                                                   });
                                            });
  }
 
  inline std::ostream &format_string(std::ostream & out, const DynList<size_t> & lens,
                                     const DynList<DynList<std::string>> & mat)
  {
    for (auto it = mat.get_it(); it.has_curr(); it.next_ne())
      {
        const auto & row = it.get_curr();
        auto line = zip(lens, row).
            template maps<std::string>([](const auto & p)
                                         {
                                           const std::string blanks(p.first > p.second.size() ?
                                                                      p.first - p.second.size() :
                                                                      0, ' ');
                                           return blanks + p.second + " ";
                                         });
        line.for_each([&out](const auto & s)
                        {
                          out << s;
                        });
        out << '\n';
      }
 
    return out;
  }
 
  inline DynList<DynList<std::string>>
  format_string(const DynList<DynList<std::string>> & mat)
  {
    if (mat.is_empty())
      return mat;
 
    const DynList<size_t> ilens = rep<size_t>(mat.nth(0).size(), 0);
    const DynList<size_t> maxs =
        mat.foldl(ilens, [](const DynList<size_t> & acu,
                            const DynList<std::string> & l)
                    {
                      return zip(acu, l).
                          maps<size_t>([](const auto & p)
                                         {
                                           return std::max(p.first, p.second.size());
                                         });
                    });
 
    return format_string(maxs, mat);
  }
 
  inline DynList<DynList<std::string>>
  format_string_csv(const DynList<DynList<std::string>> & mat)
  {
    DynList<DynList<std::string>> ret;
    for (auto row_it = mat.get_it(); row_it.has_curr(); row_it.next_ne())
      {
        const DynList<std::string> & curr_row = row_it.get_curr();
        const std::string & last = curr_row.get_last();
        DynList<std::string> row;
        for (auto it = curr_row.get_it(); it.has_curr(); it.next_ne())
          {
            const std::string & s = it.get_curr();
            if (&s == &last)
              row.append(s);
            else
              row.append(s + ",");
          }
        ret.append(row);
      }
 
    return ret;
  }
 
  inline std::string to_string(const DynList<DynList<std::string>> & mat)
  {
    std::ostringstream s;
    mat.for_each([&s](const auto & row)
                   {
                     row.for_each([&s](const std::string & str)
                                    {
                                      s << str;
                                    });
                     s << '\n';
                   });
    return s.str();
  }
 
  inline DynList<std::string> split_text_into_words(const std::string & text)
  {
    DynList<std::string> words;
    std::istringstream in(text);
    for (std::string word; in >> word;)
      words.append(word);
    return words;
  }
 
  inline DynList<std::string> split_text_into_lines(const std::string & text)
  {
    return split_to_list(text, "\n");
  }
 
  inline std::string to_string(const DynList<std::string> & lines)
  {
    std::ostringstream s;
    for (auto it = lines.get_it(); it.has_curr(); it.next_ne())
      {
        const auto & line = it.get_curr();
        s << line;
        if (line != lines.get_last())
          s << '\n';
      }
 
    return s.str();
  }
 
  inline std::string justify_line(std::string line, const size_t page_width)
  {
    if (size_t pos = line.find_first_of(' '); pos != std::string::npos)
      while (line.size() < page_width)
        {
          pos = line.find_first_not_of(' ', pos);
          if (pos == std::string::npos)
            break;
          line.insert(pos, " ");
          pos = line.find_first_of(' ', pos + 1);
          if (pos == std::string::npos)
            pos = line.find_first_of(' ');
        }
 
    return line;
  }
 
  inline std::string justify_text(const std::string & text,
                                  const size_t width,
                                  const size_t left_margin = 0)
  {
    auto words = split_text_into_words(text);
 
    std::ostringstream s;
    std::string line;
    for (const std::string & word: words)
      if (line.size() + word.size() + 1 > width)
        {
          // next word doesn't fit into the line
          if (not line.empty())
            {
              s << std::string(left_margin, ' ') << justify_line(line, width) << '\n';
              line.clear();
            }
          line = word;
        }
      else
        {
          if (not line.empty())
            line.append(" ");
          line.append(word);
        }
 
    s << std::string(left_margin, ' ') << line;
 
    return s.str();
  }
 
  inline std::string justify_line_except_first(const std::string & text,
                                               const size_t width,
                                               const size_t left_margin = 0)
  {
    const auto formatted = justify_text(text, width);
    auto lines = split_text_into_lines(formatted);
    std::ostringstream s;
    s << lines.remove_first() << '\n';
    s << justify_text(to_string(lines), width, left_margin);
    return s.str();
  }
 
  inline std::string align_text_to_left(const std::string & text,
                                        const size_t page_width,
                                        const size_t left_margin = 0)
  {
    auto words = split_text_into_words(text);
 
    const std::string margin(left_margin, ' ');
    std::ostringstream s;
    std::string line;
    for (const std::string & word: words)
      if (line.size() + word.size() + 1 > page_width)
        {
          // next word doesn't fit into the line
          if (not line.empty())
            {
              s << margin << line << '\n';
              line.clear();
            }
          line = word;
        }
      else
        {
          if (not line.empty())
            line.append(" ");
          line.append(word);
        }
 
    s << margin << line;
 
    return s.str();
  }
 
  inline std::string align_text_to_left_except_first(const std::string & text,
                                                     const size_t width,
                                                     const size_t left_margin = 0)
  {
    const auto formatted = align_text_to_left(text, width);
    auto lines = split_text_into_lines(formatted);
    std::ostringstream s;
    s << lines.remove_first() << '\n';
    s << align_text_to_left(to_string(lines), width, left_margin);
    return s.str();
  }
 
  inline std::string shift_lines_to_left(const std::string & str, const size_t n)
  {
    std::ostringstream s;
    const std::string fill(n, ' ');
    const auto lines = split_to_list(str, "\n");
    for (auto it = lines.get_it(); it.has_curr(); it.next_ne())
      {
        const auto & line = it.get_curr();
        s << fill << line;
        if (line != lines.get_last())
          s << '\n';
      }
    return s.str();
  }
 
  inline void build_pars_list(std::string & unused)
  {
    (void) unused;
  }
 
  template <typename T>
    requires requires(std::ostream & out, const T & v)
      {
        out << v;
      }
 
  inline void build_pars_list(std::string & str, const T & item)
  {
    std::ostringstream s;
    if (not str.empty())
      s << ", ";
    s << item;
    str.append(s.str());
  }
 
  template <class T, class... Args>
  inline void build_pars_list(std::string & str, const T & item, Args... args)
  {
    build_pars_list(str, item);
    build_pars_list(str, args...);
  }
 
  template <class First, class... Rest>
    requires (not requires(const std::remove_reference_t<First> & c)
      {
        c.is_empty();
        c.get_last();
        c.get_it();
      })
  inline std::string build_pars_list(const First & first, const Rest &... rest)
  {
    std::string ret;
    build_pars_list(ret, first, rest...);
    return ret;
  }
 
  template <class C>
    requires requires(const C & c)
      {
        c.is_empty();
        c.get_last();
        c.get_it();
      }
  inline std::string build_pars_list(const C & c, const std::string & sep = ",")
  {
    if (c.is_empty())
      return "";
 
    auto & last = c.get_last();
    std::ostringstream s;
    for (auto it = c.get_it(); it.has_curr(); it.next_ne())
      {
        auto & curr = it.get_curr();
        s << curr;
        if (&curr != &last)
          s << sep;
      }
    return s.str();
  }
}
 
# endif // AH_STRING_UTILS_H