string_utils.h

Go to the documentation of this file.

#ifndef STRING_UTILS_H
#define STRING_UTILS_H
 
#include <algorithm>
#include <cstdint>
#include <iterator>
#include <list>
#include <memory>
#include <sstream>
#include <string_view>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
namespace mazes
{
 
 
    class string_utils
    {
    public:
 
        static std::string concat(const std::string &a, const std::string &b) noexcept;
 
        static bool contains(const std::string &str, const std::string &substr) noexcept;
 
        static std::string get_file_extension(const std::string &filename) noexcept;
 
        static bool ends_with(const std::string &str, const std::string &suffix) noexcept;
 
        static bool find(std::string_view sv, char c) noexcept;
 
        static std::string_view find_first_of(const std::string_view &s, const std::string_view &chars) noexcept;
 
        static std::string_view strip(const std::string_view &s, const std::string_view &to_strip_from_s = " ") noexcept;
 
    private:
        // Helper trait to detect if a type has push_back method - local to this function
        template <typename T, typename = void>
        struct has_push_back : std::false_type
        {
        };
 
        template <typename T>
        struct has_push_back<T, std::void_t<decltype(std::declval<T>().push_back(std::declval<typename T::value_type>()))>> : std::true_type
        {
        };
 
        static constexpr auto eq = [](const auto &el, const auto &sep) -> bool
        {
            using std::is_convertible_v;
            using std::is_same_v;
 
            using ElType = std::decay_t<decltype(el)>;
            using SepType = std::decay_t<decltype(sep)>;
 
            if constexpr (is_same_v<ElType, SepType>)
            {
 
                return el == sep;
            }
            else if constexpr (is_convertible_v<ElType, SepType>)
            {
 
                return static_cast<SepType>(el) == sep;
            }
            else if constexpr (is_convertible_v<SepType, ElType>)
            {
 
                return el == static_cast<ElType>(sep);
            }
            else
            {
 
                return false;
            }
        };
 
    public:
        template <typename It, typename Oc, typename V, typename Pred>
        static It split(It it, const It end_it, Oc &dest, const V &sep, Pred f)
        {
 
            using std::is_same_v;
            using std::string;
 
            using SliceContainer = typename Oc::value_type;
 
            while (it != end_it)
            {
 
                SliceContainer dest_elm{};
 
                auto slice{it};
 
                while (slice != end_it)
                {
 
                    if (f(*slice, sep))
                        break;
 
                    // Handle string vs other containers
                    if constexpr (is_same_v<SliceContainer, string>)
                    {
 
                        dest_elm += *slice;
                    }
                    else if constexpr (has_push_back<SliceContainer>::value)
                    {
 
                        dest_elm.push_back(*slice);
                    }
                    else
                    {
 
                        // For types without push_back, provide a helpful error
                        static_assert(is_same_v<SliceContainer, string> || has_push_back<SliceContainer>::value,
                                      "SliceContainer must be std::string or have a push_back method");
                    }
                    ++slice;
                }
 
                dest.push_back(dest_elm);
 
                if (slice == end_it)
                {
 
                    return end_it;
                }
 
                it = ++slice;
            }
            return it;
        }
 
        template <typename It, typename Oc, typename V>
        static It split(It it, const It end_it, Oc &dest, const V &sep)
        {
 
            return split(it, end_it, dest, sep, eq);
        }
 
        template <typename Cin, typename Cout, typename V>
        static Cout &strsplit(const Cin &str, Cout &dest, const V &sep)
        {
 
            split(str.begin(), str.end(), dest, sep, eq);
 
            return dest;
        }
 
        template <typename T>
        static bool is_whitespace(const T &c)
        {
 
            using std::is_same_v;
            using std::string_view;
 
            // Use std::string_view for safer character comparison
            constexpr string_view whitespace_chars = " \t\r\n\v\f";
 
            // For character types, convert to char for comparison
            if constexpr (is_same_v<T, char>)
            {
                return whitespace_chars.find(c) != string_view::npos;
            }
            else
            {
                // For other types, do individual comparisons
                return c == static_cast<T>(' ') ||
                       c == static_cast<T>('\t') ||
                       c == static_cast<T>('\r') ||
                       c == static_cast<T>('\n') ||
                       c == static_cast<T>('\v') ||
                       c == static_cast<T>('\f');
            }
        }
 
        static std::string strip_whitespace(const std::string &s)
        {
 
            using std::string;
            using std::unique;
 
            string outputString{s};
 
            auto its = unique(outputString.begin(), outputString.end(),
                              [](const auto &a, const auto &b)
                              {
                                  return is_whitespace(a) && is_whitespace(b);
                              });
 
            outputString.erase(its, outputString.end());
 
            outputString.shrink_to_fit();
 
            return outputString;
        }
 
        template <typename... Args>
        static std::string format(std::string_view format_str, const Args &...args) noexcept;
 
    }; // class
 
} // namespace
 
#endif // STRING_UTILS_H