string_utils.h

Go to the documentation of this file.

#ifndef STRING_UTILS_H
#define STRING_UTILS_H
 
#include <algorithm>
#include <string_view>
#include <string>
#include <type_traits>
 
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;
 
    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 = []<typename T0, typename T1>(const T0& el, const T1& sep) -> bool
        {
            using std::is_convertible_v;
            using std::is_same_v;
 
            using ElType = std::decay_t<T0>;
            using SepType = std::decay_t<T1>;
 
            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};
 
            const 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