strpp.h

Go to the documentation of this file.

 
/*
Copyright (c) 2026 MrXie1109
 
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.
*/
 
#pragma once
#include <algorithm>
#include <cctype>
#include <climits>
#include <clocale>
#include <cstdint>
#include <initializer_list>
#include <iostream>
#include <locale>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
#include "../core/csexc.h"
 
namespace console {

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    ltrim(std::basic_string<CharT, Traits, Allocator> str) {
        auto it = std::find_if(str.begin(),
            str.end(),
            [](unsigned char uc) -> bool { return !isspace(uc); });
        str.erase(str.begin(), it);
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    rtrim(std::basic_string<CharT, Traits, Allocator> str) {
        auto it = std::find_if(str.rbegin(),
            str.rend(),
            [](unsigned char uc) -> bool { return !isspace(uc); });
        str.erase(it.base(), str.end());
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    trim(std::basic_string<CharT, Traits, Allocator> str) {
        auto front = std::find_if(str.begin(),
            str.end(),
            [](unsigned char uc) -> bool { return !isspace(uc); });
        if (front == str.end()) {
            str.clear();
            return str;
        }
        auto back = std::find_if(str.rbegin(),
            str.rend(),
            [](unsigned char uc) -> bool { return !isspace(uc); });
        str.erase(back.base(), str.end());
        str.erase(str.begin(), front);
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    ltrim(std::basic_string<CharT, Traits, Allocator>      str,
        const std::basic_string<CharT, Traits, Allocator> &chars) {
        auto it
            = std::find_if(str.begin(), str.end(), [&chars](unsigned char ch) {
                  return chars.find(ch)
                         == std::basic_string<CharT, Traits, Allocator>::npos;
              });
        str.erase(str.begin(), it);
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    rtrim(std::basic_string<CharT, Traits, Allocator>      str,
        const std::basic_string<CharT, Traits, Allocator> &chars) {
        auto it = std::find_if(
            str.rbegin(), str.rend(), [&chars](unsigned char ch) {
                return chars.find(ch)
                       == std::basic_string<CharT, Traits, Allocator>::npos;
            });
        str.erase(it.base(), str.end());
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    trim(std::basic_string<CharT, Traits, Allocator>       str,
        const std::basic_string<CharT, Traits, Allocator> &chars) {
        auto front
            = std::find_if(str.begin(), str.end(), [&chars](unsigned char ch) {
                  return chars.find(ch)
                         == std::basic_string<CharT, Traits, Allocator>::npos;
              });
        if (front == str.end()) {
            str.clear();
            return str;
        }
        auto back = std::find_if(
            str.rbegin(), str.rend(), [&chars](unsigned char ch) {
                return chars.find(ch)
                       == std::basic_string<CharT, Traits, Allocator>::npos;
            });
        str.erase(back.base(), str.end());
        str.erase(str.begin(), front);
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    upper(std::basic_string<CharT, Traits, Allocator> str,
        const std::locale                            &loc = std::locale{}) {
        for (auto &ch : str) ch = std::toupper(ch, loc);
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    lower(std::basic_string<CharT, Traits, Allocator> str,
        const std::locale                            &loc = std::locale{}) {
        for (auto &ch : str) ch = std::tolower(ch, loc);
        return str;
    }

    template <class CharT, class Traits, class Allocator>
    std::basic_string<CharT, Traits, Allocator>
    title(std::basic_string<CharT, Traits, Allocator> str,
        const std::locale                            &loc = std::locale{}) {
        using string_type = std::basic_string<CharT, Traits, Allocator>;
        if (str.empty()) return string_type{};
        str[0] = std::toupper(str[0], loc);
        for (size_t i = 1; i < str.size(); ++i) {
            if (std::isspace(str[i - 1], loc))
                str[i] = std::toupper(str[i], loc);
            else
                str[i] = std::tolower(str[i], loc);
        }
        return str;
    }

    template <class CharT = char,
        class Traits      = std::char_traits<CharT>,
        class Allocator   = std::allocator<CharT>>
    struct BasicPartitionResult {
        using string_type = std::basic_string<CharT, Traits, Allocator>;
 
        string_type left;   
        string_type middle; 
        string_type right;  

        friend std::basic_ostream<CharT, Traits> &
        operator<<(std::basic_ostream<CharT, Traits> &os,
            const BasicPartitionResult               &pr) {
            return os << "BasicPartitionResult(\"" << pr.left << "\", \""
                      << pr.middle << "\", \"" << pr.right << "\")";
        }
    };

    using PartitionResult = BasicPartitionResult<char>;
    using WPartitionResult = BasicPartitionResult<wchar_t>;

    template <class CharT, class Traits, class Allocator>
    BasicPartitionResult<CharT, Traits, Allocator>
    partition(const std::basic_string<CharT, Traits, Allocator> &text,
        const std::basic_string<CharT, Traits, Allocator>       &sep) {
        using string_type = std::basic_string<CharT, Traits, Allocator>;
        size_t pos        = text.find(sep);
        if (pos == string_type::npos)
            return BasicPartitionResult<CharT, Traits, Allocator>{
                text, string_type{}, string_type{}};
        return BasicPartitionResult<CharT, Traits, Allocator>{
            text.substr(0, pos), sep, text.substr(pos + sep.size())};
    }

    template <class CharT, class Traits, class Allocator>
    std::vector<std::basic_string<CharT, Traits, Allocator>>
    split(const std::basic_string<CharT, Traits, Allocator> &text,
        const std::basic_string<CharT, Traits, Allocator>   &sep
        = std::basic_string<CharT, Traits, Allocator>(1, CharT{' '})) {
        using string_type = std::basic_string<CharT, Traits, Allocator>;
        using vector_type = std::vector<string_type>;
        vector_type result;
        if (sep.empty()) return {text};
        size_t start = 0;
        while (start <= text.size()) {
            size_t pos = text.find(sep, start);
            if (pos == string_type::npos) {
                result.push_back(text.substr(start));
                break;
            }
            result.push_back(text.substr(start, pos - start));
            start = pos + sep.size();
        }
        return result;
    }

    template <class T,
        class CharT     = char,
        class Traits    = std::char_traits<CharT>,
        class Allocator = std::allocator<CharT>>
    std::basic_string<CharT, Traits, Allocator> join(const std::vector<T> &vec,
        const std::basic_string<CharT, Traits, Allocator>                 &sep
        = std::basic_string<CharT, Traits, Allocator>{}) {
        using string_type = std::basic_string<CharT, Traits, Allocator>;
        if (vec.empty()) return string_type{};
        std::basic_ostringstream<CharT, Traits> ss;
        auto                                    it = vec.begin();
        ss << *it;
        while (++it != vec.end()) ss << sep << *it;
        return ss.str();
    }

    inline std::string ltrim(const char *str) {
        return ltrim(std::string(str));
    }

    inline std::wstring ltrim(const wchar_t *str) {
        return ltrim(std::wstring(str));
    }

    inline std::string rtrim(const char *str) {
        return rtrim(std::string(str));
    }

    inline std::wstring rtrim(const wchar_t *str) {
        return rtrim(std::wstring(str));
    }

    inline std::string trim(const char *str) {
        return trim(std::string(str));
    }

    inline std::wstring trim(const wchar_t *str) {
        return trim(std::wstring(str));
    }

    inline std::string ltrim(const char *str, const std::string &chars) {
        return ltrim(std::string(str), chars);
    }

    inline std::wstring ltrim(const wchar_t *str, const std::wstring &chars) {
        return ltrim(std::wstring(str), chars);
    }

    inline std::string rtrim(const char *str, const std::string &chars) {
        return rtrim(std::string(str), chars);
    }

    inline std::wstring rtrim(const wchar_t *str, const std::wstring &chars) {
        return rtrim(std::wstring(str), chars);
    }

    inline std::string trim(const char *str, const std::string &chars) {
        return trim(std::string(str), chars);
    }

    inline std::wstring trim(const wchar_t *str, const std::wstring &chars) {
        return trim(std::wstring(str), chars);
    }

    inline std::string ltrim(const char *str, const char *chars) {
        return ltrim(std::string(str), std::string(chars));
    }

    inline std::wstring ltrim(const wchar_t *str, const wchar_t *chars) {
        return ltrim(std::wstring(str), std::wstring(chars));
    }

    inline std::string rtrim(const char *str, const char *chars) {
        return rtrim(std::string(str), std::string(chars));
    }

    inline std::wstring rtrim(const wchar_t *str, const wchar_t *chars) {
        return rtrim(std::wstring(str), std::wstring(chars));
    }

    inline std::string trim(const char *str, const char *chars) {
        return trim(std::string(str), std::string(chars));
    }

    inline std::wstring trim(const wchar_t *str, const wchar_t *chars) {
        return trim(std::wstring(str), std::wstring(chars));
    }

    inline std::string ltrim(const std::string &str, const char *chars) {
        return ltrim(str, std::string(chars));
    }

    inline std::wstring ltrim(const std::wstring &str, const wchar_t *chars) {
        return ltrim(str, std::wstring(chars));
    }

    inline std::string rtrim(const std::string &str, const char *chars) {
        return rtrim(str, std::string(chars));
    }

    inline std::wstring rtrim(const std::wstring &str, const wchar_t *chars) {
        return rtrim(str, std::wstring(chars));
    }

    inline std::string trim(const std::string &str, const char *chars) {
        return trim(str, std::string(chars));
    }

    inline std::wstring trim(const std::wstring &str, const wchar_t *chars) {
        return trim(str, std::wstring(chars));
    }

    inline std::string
    upper(const char *str, const std::locale &loc = std::locale{}) {
        return upper(std::string(str), loc);
    }

    inline std::wstring
    upper(const wchar_t *str, const std::locale &loc = std::locale{}) {
        return upper(std::wstring(str), loc);
    }

    inline std::string
    lower(const char *str, const std::locale &loc = std::locale{}) {
        return lower(std::string(str), loc);
    }

    inline std::wstring
    lower(const wchar_t *str, const std::locale &loc = std::locale{}) {
        return lower(std::wstring(str), loc);
    }

    inline std::string
    title(const char *str, const std::locale &loc = std::locale{}) {
        return title(std::string(str), loc);
    }

    inline std::wstring
    title(const wchar_t *str, const std::locale &loc = std::locale{}) {
        return title(std::wstring(str), loc);
    }

    template <class CharT, class Traits, class Allocator>
    BasicPartitionResult<CharT, Traits, Allocator>
    partition(const std::basic_string<CharT, Traits, Allocator> &text,
        const CharT                                             *sep) {
        return partition(
            text, std::basic_string<CharT, Traits, Allocator>(sep));
    }

    template <class CharT, class Traits, class Allocator>
    std::vector<std::basic_string<CharT, Traits, Allocator>>
    split(const std::basic_string<CharT, Traits, Allocator> &text,
        const CharT                                         *sep) {
        return split(text, std::basic_string<CharT, Traits, Allocator>(sep));
    }

    inline BasicPartitionResult<>
    partition(const char *text, const std::string &sep) {
        return partition(std::string(text), sep);
    }

    inline BasicPartitionResult<wchar_t>
    partition(const wchar_t *text, const std::wstring &sep) {
        return partition(std::wstring(text), sep);
    }

    inline std::vector<std::string>
    split(const char *text, const std::string &sep = " ") {
        return split(std::string(text), sep);
    }

    inline std::vector<std::wstring>
    split(const wchar_t *text, const std::wstring &sep = L" ") {
        return split(std::wstring(text), sep);
    }

    inline std::string
    join(const std::vector<std::string> &items, const std::string &sep = "") {
        std::string result;
        for (const auto &item : items) {
            if (!result.empty()) result += sep;
            result += item;
        }
        return result;
    }

    inline std::wstring join(
        const std::vector<std::wstring> &items, const std::wstring &sep = L"") {
        std::wstring result;
        for (const auto &item : items) {
            if (!result.empty()) result += sep;
            result += item;
        }
        return result;
    }

    template <class CharT, class Traits>
    inline void to_stream(char ch, std::basic_ostream<CharT, Traits> &os) {
        os << ch;
    }

    template <class CharT, class Traits>
    inline void to_stream(wchar_t wch, std::basic_ostream<CharT, Traits> &os) {
        os << std::wcout.narrow(wch, '?');
    }

    template <class Traits>
    inline void
    to_stream(wchar_t wch, std::basic_ostream<wchar_t, Traits> &os) {
        os << wch;
    }

    template <class CharT, class Traits>
    inline void
    to_stream(const std::string &str, std::basic_ostream<CharT, Traits> &os) {
        os << str.c_str();
    }

    template <class CharT, class Traits>
    inline void
    to_stream(const std::wstring &wstr, std::basic_ostream<CharT, Traits> &os) {
        for (wchar_t wch : wstr) to_stream(wch, os);
    }

    template <class CharT, class Traits>
    inline void
    to_stream(const char *str, std::basic_ostream<CharT, Traits> &os) {
        if (str == nullptr) return;
        os << str;
    }

    template <class CharT, class Traits>
    inline void
    to_stream(const wchar_t *wstr, std::basic_ostream<CharT, Traits> &os) {
        for (const wchar_t *p = wstr; p && *p; ++p) to_stream(*p, os);
    }
 
    template <class CharT, class Traits, std::size_t N>
    inline void
    to_stream(char (&arr)[N], std::basic_ostream<CharT, Traits> &os) {
        to_stream(static_cast<const char *>(arr), os);
    }
 
    template <class CharT, class Traits, std::size_t N>
    inline void
    to_stream(wchar_t (&arr)[N], std::basic_ostream<CharT, Traits> &os) {
        to_stream(static_cast<const wchar_t *>(arr), os);
    }
 
    template <class CharT, class Traits, class T>
    inline typename std::enable_if<
        !std::is_same<typename std::decay<T>::type, char>::value &&        //
        !std::is_same<typename std::decay<T>::type, wchar_t>::value &&     //
        !std::is_same<typename std::decay<T>::type, char *>::value &&      //
        !std::is_same<typename std::decay<T>::type, wchar_t *>::value &&   //
        !std::is_same<typename std::decay<T>::type, std::string>::value && //
        !std::is_same<typename std::decay<T>::type, std::wstring>::value   //
        >::type
    to_stream(T &&value, std::basic_ostream<CharT, Traits> &os) {
        os << std::forward<T>(value);
    }

    template <class... Args>
    std::string to_string(Args &&...args) {
        std::ostringstream oss;
        int                _[] = {0, (to_stream(args, oss), 0)...};
        (void)_;
        return oss.str();
    }

    template <class CharT, class Traits, class Allocator, class... Args>
    void from_string(
        std::basic_string<CharT, Traits, Allocator> str, Args &...args) {
        std::basic_istringstream<CharT, Traits> iss(str);
        int                                     _[] = {0, (iss >> args, 0)...};
        (void)_;
    }
 // end of strpp group
}