string.h

#ifndef WREPORT_STRING_H
#define WREPORT_STRING_H

#include <cctype>
#include <functional>
#include <sstream>
#include <string>

namespace wreport::str {

inline bool startswith(const std::string& str, const std::string& part)
{
    if (str.size() < part.size())
        return false;
    return str.substr(0, part.size()) == part;
}

inline bool endswith(const std::string& str, const std::string& part)
{
    if (str.size() < part.size())
        return false;
    return str.substr(str.size() - part.size()) == part;
}

template <typename ITER>
std::string join(const std::string& sep, const ITER& begin, const ITER& end)
{
    std::stringstream res;
    bool first = true;
    for (ITER i = begin; i != end; ++i)
    {
        if (first)
            first = false;
        else
            res << sep;
        res << *i;
    }
    return res.str();
}

template <typename ITEMS>
std::string join(const std::string& sep, const ITEMS& items)
{
    std::stringstream res;
    bool first = true;
    for (const auto& i : items)
    {
        if (first)
            first = false;
        else
            res << sep;
        res << i;
    }
    return res.str();
}

std::string lstrip(const std::string& str);

std::string rstrip(const std::string& str);

std::string strip(const std::string& str);

inline std::string upper(const std::string& str)
{
    std::string res;
    res.reserve(str.size());
    for (std::string::const_iterator i = str.begin(); i != str.end(); ++i)
        res += static_cast<char>(std::toupper(static_cast<unsigned char>(*i)));
    return res;
}

inline std::string lower(const std::string& str)
{
    std::string res;
    res.reserve(str.size());
    for (std::string::const_iterator i = str.begin(); i != str.end(); ++i)
        res += static_cast<char>(std::tolower(static_cast<unsigned char>(*i)));
    return res;
}

[[deprecated("Use path.filename")]] std::string
basename(const std::string& pathname);

[[deprecated("Use path.parent_path")]] std::string
dirname(const std::string& pathname);

[[deprecated("Use path / path")]] void appendpath(std::string& dest,
                                                  const char* path2);

[[deprecated("Use path / path")]] void appendpath(std::string& dest,
                                                  const std::string& path2);

template <typename S1, typename S2, typename... Args>
[[deprecated("Use path / path")]] void appendpath(std::string& dest, S1 first,
                                                  S2 second, Args... next)
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    appendpath(dest, first);
    appendpath(dest, second, next...);
#pragma GCC diagnostic pop
}

template <typename... Args>
[[deprecated("Use path / path")]] std::string joinpath(Args... components)
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    std::string res;
    appendpath(res, components...);
    return res;
#pragma GCC diagnostic pop
}

[[deprecated(
    "use path::lexically_normal or std::filesystem::canonical")]] std::string
normpath(const std::string& pathname);

struct Split
{
    std::string str;
    std::string sep;
    bool skip_empty;

    Split(const std::string& str_, const std::string& sep_,
          bool skip_empty_ = false)
        : str(str_), sep(sep_), skip_empty(skip_empty_)
    {
    }

    class const_iterator
    {
    protected:
        const Split* split = nullptr;
        std::string cur;
        size_t end = 0;

        void skip_separators();

    public:
        using iterator_category = std::input_iterator_tag;
        using value_type        = std::string;
        using difference_type   = int;
        using pointer           = std::string*;
        using reference         = std::string&;

        const_iterator(const Split& split);
        const_iterator() : cur() {}
        const_iterator(const const_iterator&) = default;
        ~const_iterator();

        const_iterator& operator++();
        const std::string& operator*() const;
        const std::string* operator->() const;

        std::string remainder() const;

        const_iterator& operator=(const const_iterator&) = default;
        bool operator==(const const_iterator& ti) const;
        bool operator!=(const const_iterator& ti) const;
    };

    const_iterator begin() { return const_iterator(*this); }

    const_iterator end() { return const_iterator(); }
};

std::string encode_cstring(const std::string& str);

std::string decode_cstring(const std::string& str, size_t& lenParsed);

std::string encode_url(const std::string& str);

std::string decode_url(const std::string& str);

std::string encode_base64(const std::string& str);

std::string encode_base64(const void* data, size_t size);

std::string decode_base64(const std::string& str);

} // namespace wreport::str
#endif