stringops.h

Go to the documentation of this file.

/* *****************************************************************************
 * kblib is a general utility library for C++14 and C++17, intended to provide
 * performant high-level abstractions and more expressive ways to do simple
 * things.
 *
 * Copyright (c) 2021 killerbee
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 * ****************************************************************************/
 
#ifndef KBLIB_STRINGOPS_H
#define KBLIB_STRINGOPS_H
 
#include "algorithm.h"
#include "format.h"
#include "tdecl.h"
#include "traits.h"
 
#include <algorithm>
#include <cctype>
#include <cwctype>
#include <initializer_list>
#include <numeric>
#include <string>
#include <type_traits>
 
#if KBLIB_USE_CXX17
#  include <string_view>
#endif
 
namespace KBLIB_NS {
 
#if true or KBLIB_USE_CXX17
template <typename C>
struct is_character
    : contains_type<std::tuple<char, wchar_t, char16_t, char32_t
#  if __cpp_char8_t
                               ,
                               char8_t
#  endif
                               >,
                    std::decay_t<C>> {
};
 
template <typename C>
constexpr bool is_character_v = is_character<C>::value;
 
namespace detail {
 
   template <typename T, bool = std::is_arithmetic<T>::value>
   struct arithmetic_type {
      using type = void;
   };
   template <typename T>
   struct arithmetic_type<T, true> {
      using type = T;
   };
   template <typename T>
   using arithmetic_type_t = typename arithmetic_type<T>::type;
 
   template <typename T, typename = arithmetic_type_t<T>>
   struct str_type {
      using type = std::string;
      KBLIB_NODISCARD static auto convert(T in) -> std::string {
         return std::to_string(in);
      }
   };
   template <typename T>
   struct str_type<T, void> {
      using type = std::conditional_t<std::is_convertible_v<T, std::string>,
                                      std::string, T>;
      KBLIB_NODISCARD static auto convert(T&& in) -> type {
         return std::forward<T>(in);
      }
   };
   template <>
   struct str_type<char, char> {
      using type = char;
      KBLIB_NODISCARD static auto convert(char in) -> char { return in; }
   };
   template <>
   struct str_type<wchar_t, wchar_t> {
      using type = wchar_t;
      KBLIB_NODISCARD static auto convert(wchar_t in) -> wchar_t { return in; }
   };
   template <>
   struct str_type<char16_t, char16_t> {
      using type = char16_t;
      KBLIB_NODISCARD static auto convert(char16_t in) -> char16_t {
         return in;
      }
   };
   template <>
   struct str_type<char32_t, char32_t> {
      using type = char32_t;
      KBLIB_NODISCARD static auto convert(char32_t in) -> char32_t {
         return in;
      }
   };
#  if __cpp_char8_t
   template <>
   struct str_type<char8_t, char8_t> {
      using type = char8_t;
      KBLIB_NODISCARD static auto convert(char8_t in) -> char8_t { return in; }
   };
#  endif
   template <typename T>
   using str_type_t = typename str_type<T>::type;
 
} // namespace detail
 
#  if KBLIB_USE_CXX17
template <typename Str>
KBLIB_NODISCARD constexpr auto strsize(Str&& str) -> std::size_t {
   if constexpr (std::is_array_v<std::remove_reference_t<Str>>) {
      return fakestd::size(str);
   } else if constexpr (std::is_pointer_v<std::decay_t<Str>>) {
      return std::char_traits<std::decay_t<decltype(*str)>>::length(str);
   } else if constexpr (is_character_v<std::decay_t<Str>>) {
      return 1;
   } else if constexpr (std::is_integral_v<std::decay_t<Str>>) {
      return to_unsigned(count_digits(str));
   } else if constexpr (std::is_floating_point_v<std::decay_t<Str>>) {
      return to_unsigned(count_digits(str));
   } else {
      return fakestd::size(str);
   }
}
 
template <typename CharT>
KBLIB_NODISCARD constexpr auto length(const CharT* str) noexcept
    -> std::size_t {
   return std::char_traits<CharT>::length(str);
}
 
template <typename string, typename F, typename... S>
constexpr auto append(string&& out, F&& f, S&&... tail) -> void {
   if constexpr (is_character_v<std::decay_t<F>>) {
      out.append(1, f);
   } else if constexpr (std::is_arithmetic_v<std::decay_t<F>>) {
      out.append(std::to_string(f));
   } else {
      out.append(f);
   }
   if constexpr (sizeof...(S) > 0) {
      append(out, tail...);
   }
   return;
}
 
namespace detail {
 
   template <std::size_t I, typename T>
   struct value {
      T v;
   };
 
   template <class Idxs, class... Ts>
   struct values;
 
   template <std::size_t... Idxs, typename... Ts>
   struct values<std::index_sequence<Idxs...>, Ts...> : value<Idxs, Ts>... {};
 
   template <typename string, typename... S, std::size_t... I>
   KBLIB_NODISCARD constexpr auto concat_impl(std::index_sequence<I...>,
                                              S&&... ins) -> string {
      values<std::index_sequence<I...>, detail::str_type_t<S>...> buf{
          {detail::str_type<S>::convert(std::forward<S>(ins))}...};
      string ret;
      std::size_t size
          = (strsize(static_cast<value<I, detail::str_type_t<S>>&>(buf).v) + ...
             + 0);
      ret.reserve(size);
      append(ret, static_cast<value<I, detail::str_type_t<S>>&>(buf).v...);
      return ret;
   }
 
} // namespace detail
 
template <typename string = std::string, typename F, typename... S>
KBLIB_NODISCARD constexpr auto concat(F&& f, S&&... ins) -> string {
   return detail::concat_impl<string>(
       std::make_index_sequence<1 + sizeof...(S)>{}, std::forward<F>(f),
       std::forward<S>(ins)...);
}
 
template <typename string = std::string, typename str>
KBLIB_NODISCARD constexpr auto concat(std::initializer_list<str> ins)
    -> string {
   string ret;
   ret.reserve(std::accumulate(
       ins.begin(), ins.end(), std::size_t{0},
       [](std::size_t z, const str& s) { return z + strsize(s); }));
   for (auto&& s : ins) {
      append(ret, s);
   }
   return ret;
}
#  endif
 
KBLIB_NODISCARD constexpr auto isspace(char c) -> bool {
   return std::isspace(to_unsigned(c));
}
KBLIB_NODISCARD constexpr auto isspace(wchar_t c) -> bool {
   return iswspace(to_unsigned(c));
}
 
struct is_space {
   KBLIB_NODISCARD auto operator()(char c) -> bool { return isspace(c); }
   KBLIB_NODISCARD auto operator()(wchar_t c) -> bool { return isspace(c); }
};
 
KBLIB_NODISCARD constexpr auto isAspace(char c) -> bool {
   for (auto v : " \t\r\n\f\v") {
      if (c == v) {
         return true;
      }
   }
   return false;
}
KBLIB_NODISCARD constexpr auto isAspace(wchar_t c) -> bool {
   for (auto v : L" \t\r\n\f\v") {
      if (c == v) {
         return true;
      }
   }
   return false;
}
 
template <typename range, typename string = std::string>
KBLIB_NODISCARD constexpr auto join(const range& in,
                                    const string& joiner = "") {
   if (fakestd::size(in) > 0) {
 
      auto len = kblib::accumulate(
          begin(in), end(in), std::size_t{},
          [](std::size_t l, const auto& x) { return l + strsize(x); });
      auto ret = *begin(in);
      try_reserve(ret, len);
      kblib::copy(next(begin(in)), end(in),
                  consumer([&](const auto& x) { append(ret, joiner, x); }));
      return ret;
   } else {
      return typename value_type_linear<range>::type{};
   }
}
#endif // KBLIB_USE_CXX17
 
template <typename Container = std::vector<std::string>, typename Predicate,
          typename String>
KBLIB_NODISCARD constexpr auto split_tokens(const String& in, Predicate spacer)
    -> return_assert_t<
        is_callable<Predicate,
                    typename Container::value_type::value_type>::value,
        Container> {
   Container ret{};
   bool delim_run = true;
   const char* begpos{};
   auto endpos = begpos;
   for (const auto& c : in) {
      if (delim_run) {
         // keep begpos updated as long as in a delimiter run
         begpos = &c;
      }
      if (spacer(c) and not std::exchange(delim_run, true)) {
         // c is first of a run of delimiters
         ret.emplace_back(begpos, &c - begpos);
      } else if (not spacer(c)) {
         // c is not a delimiter
         delim_run = false;
      }
      endpos = &c;
   }
   if (not std::exchange(delim_run, true)) {
      ret.emplace_back(begpos, endpos + 1);
   }
   if (not delim_run and begpos != endpos) {
      ret.emplace_back(begpos, endpos - begpos + 1);
   }
   return ret;
}
 
template <typename Container = std::vector<std::string>, typename String>
KBLIB_NODISCARD constexpr auto split_tokens(const String& in) -> Container {
   return split_tokens(in, is_space{});
}
 
template <typename Container = std::vector<std::string>, typename String>
KBLIB_NODISCARD constexpr auto split_tokens(
    const String& in,
    typename Container::value_type::value_type delim) -> Container {
   Container ret{};
   bool delim_run = true;
   using CharT = typename Container::value_type::value_type;
   const CharT* begpos{};
   auto endpos = begpos;
   for (const CharT& c : in) {
      if (delim_run) {
         // keep begpos updated as long as in a delimiter run
         begpos = &c;
      }
      if (c == delim and not std::exchange(delim_run, true)) {
         // c is first of a run of delimiters
         ret.emplace_back(begpos, &c - begpos);
      } else if (c != delim) {
         // c is not a delimiter
         delim_run = false;
      }
      endpos = &c;
   }
   if (not delim_run and begpos != endpos) {
      ret.emplace_back(&*begpos, endpos - begpos + 1);
   }
   return ret;
}
 
template <typename Container = std::vector<std::string>, typename String>
KBLIB_NODISCARD constexpr auto kbsplit2(const String& in,
                                        char delim = ' ') -> Container {
   Container ret{""};
   bool delim_run = true;
   for (char c : in) {
      if (c == delim and not std::exchange(delim_run, true)) {
         // c is first of a run of delimiters
         ret.emplace_back();
      } else if (c != delim) {
         // c is not a delimiter
         delim_run = false;
         ret.back().push_back(c);
      }
   }
   if (ret.back().empty()) {
      ret.pop_back();
   }
   return ret;
}
 
template <typename Container = std::vector<std::string>, typename String>
KBLIB_NODISCARD constexpr auto split_dsv(const String& str,
                                         char delim) -> Container {
   Container ret;
   for (std::size_t pos1{}, pos2{str.find(delim)}; pos1 != str.npos;) {
      ret.emplace_back(str, pos1, pos2 - pos1);
      pos1 = std::exchange(pos2, str.find(delim, pos2 + 1));
      if (pos1 != str.npos) {
         ++pos1;
      }
   }
   return ret;
}
 
template <typename Container = std::vector<std::string>, typename String,
          typename Predicate>
KBLIB_NODISCARD constexpr auto split_dsv(const String& str, Predicate delim)
    -> return_assert_t<
        is_callable<Predicate,
                    typename Container::value_type::value_type>::value,
        Container> {
   Container ret;
   for (std::size_t pos1{}, pos2{str.find(delim)}; pos1 != str.npos;) {
      ret.emplace_back(str, pos1, pos2 - pos1);
      pos1 = std::exchange(
          pos2, kblib::find_in_if(str.begin() + pos1 + 1, str.end(), delim));
      if (pos1 != str.npos) {
         ++pos1;
      }
   }
   return ret;
}
 
// TODO(killerbee13): figure out if any uses of reverseStr, toLower, toUpper
// exist in current projects
 
template <typename string>
KBLIB_NODISCARD constexpr auto reverse_str(string val) -> string {
   std::reverse(val.begin(), val.end());
   return val;
}
 
namespace detail {
 
   template <typename CharT>
   KBLIB_NODISCARD constexpr auto to_int_type(CharT ch) {
      return std::char_traits<CharT>::to_int_type(ch);
   }
   template <typename CharT, typename IntT>
   KBLIB_NODISCARD constexpr auto to_char_type(IntT ch) {
      return std::char_traits<CharT>::to_char_type(ch);
   }
 
   KBLIB_NODISCARD constexpr auto tolower(char ch) {
      return to_char_type<char>(std::tolower(to_int_type(ch)));
   }
 
   KBLIB_NODISCARD constexpr auto towlower(wchar_t ch) {
      return to_char_type<wchar_t>(std::towlower(to_int_type(ch)));
   }
 
   KBLIB_NODISCARD constexpr auto toupper(char ch) {
      return to_char_type<char>(std::toupper(to_int_type(ch)));
   }
 
   KBLIB_NODISCARD constexpr auto towupper(wchar_t ch) {
      return to_char_type<wchar_t>(std::towupper(to_int_type(ch)));
   }
} // namespace detail
template <typename string>
KBLIB_NODISCARD constexpr auto tolower(string str) -> string {
   std::transform(str.begin(), str.end(), str.begin(),
                  [](auto c) { return detail::tolower(c); });
   return str;
}
 
template <typename string>
KBLIB_NODISCARD constexpr auto toupper(string str) -> string {
   std::transform(str.begin(), str.end(), str.begin(),
                  [](auto c) { return detail::toupper(c); });
   return str;
}
 
template <typename string>
KBLIB_NODISCARD constexpr auto repeat(string val, std::size_t count) -> string {
   string tmp;
   try_reserve(tmp, fakestd::size(val) * count);
   for (std::size_t i = 0; i < count; ++i) {
      tmp += val;
   }
   return tmp;
}
KBLIB_NODISCARD constexpr auto repeat(char val,
                                      std::size_t count) -> std::string {
   return std::string(count, val);
}
 
#if KBLIB_USE_STRING_VIEW
 
KBLIB_NODISCARD constexpr auto ends_with(std::string_view haystack,
                                         std::string_view needle) -> bool {
   return haystack.size() >= needle.size()
          and haystack.compare(haystack.size() - needle.size(),
                               std::string_view::npos, needle)
                  == 0;
}
 
KBLIB_NODISCARD constexpr auto ends_with(std::string_view haystack,
                                         char needle) -> bool {
   return not haystack.empty() and haystack.back() == needle;
}
 
KBLIB_NODISCARD constexpr auto starts_with(std::string_view haystack,
                                           std::string_view needle) -> bool {
   return haystack.size() >= needle.size()
          and haystack.compare(0, needle.size(), needle) == 0;
}
 
KBLIB_NODISCARD constexpr auto starts_with(std::string_view haystack,
                                           char needle) -> bool {
   return not haystack.empty() and haystack.front() == needle;
}
 
#endif
 
} // namespace KBLIB_NS
 
#endif // KBLIB_STRINGOPS_H