string.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_STRING_HEADER
#define LIBFILEZILLA_STRING_HEADER
 
#include "libfilezilla.hpp"
 
#include <algorithm>
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
 
namespace fz {
 
#ifdef FZ_WINDOWS
typedef std::wstring native_string;
typedef std::wstring_view native_string_view;
#endif
#if defined(FZ_UNIX) || defined(FZ_MAC)
typedef std::string native_string;
typedef std::string_view native_string_view;
#endif
 
native_string FZ_PUBLIC_SYMBOL to_native(std::string_view const& in);
 
native_string FZ_PUBLIC_SYMBOL to_native(std::wstring_view const& in);
 
template<typename T, typename std::enable_if_t<std::is_same_v<native_string, typename std::decay_t<T>>, int> = 0>
inline native_string to_native(T const& in) {
    return in;
}
 
int FZ_PUBLIC_SYMBOL stricmp(std::string_view const& a, std::string_view const& b);
int FZ_PUBLIC_SYMBOL stricmp(std::wstring_view const& a, std::wstring_view const& b);
 
template<typename Char>
Char tolower_ascii(Char c) {
    if (c >= 'A' && c <= 'Z') {
        return c + ('a' - 'A');
    }
    return c;
}
 
template<>
std::wstring::value_type FZ_PUBLIC_SYMBOL tolower_ascii(std::wstring::value_type c);
 
template<typename Char>
Char toupper_ascii(Char c) {
    if (c >= 'a' && c <= 'z') {
        return c + ('A' - 'a');
    }
    return c;
}
 
template<>
std::wstring::value_type FZ_PUBLIC_SYMBOL toupper_ascii(std::wstring::value_type c);
 
 // Note: For UTF-8 strings it works on individual octets!
std::string FZ_PUBLIC_SYMBOL str_tolower_ascii(std::string_view const& s);
std::wstring FZ_PUBLIC_SYMBOL str_tolower_ascii(std::wstring_view const& s);
 
std::string FZ_PUBLIC_SYMBOL str_toupper_ascii(std::string_view const& s);
std::wstring FZ_PUBLIC_SYMBOL str_toupper_ascii(std::wstring_view const& s);
 
struct FZ_PUBLIC_SYMBOL less_insensitive_ascii final
{
    template<typename T>
    bool operator()(T const& lhs, T const& rhs) const {
        return std::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend(),
            [](typename T::value_type const& a, typename T::value_type const& b) {
                return tolower_ascii(a) < tolower_ascii(b);
            }
        );
    }
};
 
inline bool equal_insensitive_ascii(std::string_view a, std::string_view b)
{
    return std::equal(a.cbegin(), a.cend(), b.cbegin(), b.cend(),
        [](auto const& a, auto const& b) {
            return tolower_ascii(a) == tolower_ascii(b);
        }
    );
}
inline bool equal_insensitive_ascii(std::wstring_view a, std::wstring_view b)
{
    return std::equal(a.cbegin(), a.cend(), b.cbegin(), b.cend(),
        [](auto const& a, auto const& b) {
            return tolower_ascii(a) == tolower_ascii(b);
        }
    );
}
 
std::wstring FZ_PUBLIC_SYMBOL to_wstring(std::string_view const& in);
 
template <typename T>
inline auto to_wstring(T && in) -> decltype(std::wstring(std::forward<T>(in)))
{
    return std::wstring(std::forward<T>(in));
}
 
template<typename Arg>
inline typename std::enable_if<std::is_arithmetic_v<std::decay_t<Arg>>, std::wstring>::type to_wstring(Arg && arg)
{
    return std::to_wstring(std::forward<Arg>(arg));
}
 
 
std::wstring FZ_PUBLIC_SYMBOL to_wstring_from_utf8(std::string_view const& in);
std::wstring FZ_PUBLIC_SYMBOL to_wstring_from_utf8(char const* s, size_t len);
 
class buffer;
std::wstring FZ_PUBLIC_SYMBOL to_wstring_from_utf8(fz::buffer const& in);
 
std::string FZ_PUBLIC_SYMBOL to_string(std::wstring_view const& in);
 
template <typename T>
inline auto to_string(T && in) -> decltype(std::string(std::forward<T>(in)))
{
    return std::string(std::forward<T>(in));
}
 
 
template<typename Arg>
inline typename std::enable_if<std::is_arithmetic_v<std::decay_t<Arg>>, std::string>::type to_string(Arg && arg)
{
    return std::to_string(std::forward<Arg>(arg));
}
 
 
template<typename Char>
size_t strlen(Char const* str) {
    return std::char_traits<Char>::length(str);
}
 
 
std::string FZ_PUBLIC_SYMBOL to_utf8(std::string_view const& in);
 
std::string FZ_PUBLIC_SYMBOL to_utf8(std::wstring_view const& in);
 
template<typename String, typename Arg>
inline auto toString(Arg&& arg) -> typename std::enable_if<std::is_same_v<String, std::string>, decltype(to_string(std::forward<Arg>(arg)))>::type
{
    return to_string(std::forward<Arg>(arg));
}
 
template<typename String, typename Arg>
inline auto toString(Arg&& arg) -> typename std::enable_if<std::is_same_v<String, std::wstring>, decltype(to_wstring(std::forward<Arg>(arg)))>::type
{
    return to_wstring(std::forward<Arg>(arg));
}
 
#if !defined(fzT) || defined(DOXYGEN)
#ifdef FZ_WINDOWS
#define fzT(x) L ## x
#else
#define fzT(x) x
#endif
#endif
 
template<typename Char>
Char const* choose_string(char const* c, wchar_t const* w);
 
template<> inline char const* choose_string(char const* c, wchar_t const*) { return c; }
template<> inline wchar_t const* choose_string(char const*, wchar_t const* w) { return w; }
 
#if !defined(fzS) || defined(DOXYGEN)
#define fzS(Char, s) fz::choose_string<Char>(s, L ## s)
#endif
 
std::string FZ_PUBLIC_SYMBOL replaced_substrings(std::string_view const& in, std::string_view const& find, std::string_view const& replacement);
std::wstring FZ_PUBLIC_SYMBOL replaced_substrings(std::wstring_view const& in, std::wstring_view const& find, std::wstring_view const& replacement);
 
std::string FZ_PUBLIC_SYMBOL replaced_substrings(std::string_view const& in, char find, char replacement);
std::wstring FZ_PUBLIC_SYMBOL replaced_substrings(std::wstring_view const& in, wchar_t find, wchar_t replacement);
 
bool FZ_PUBLIC_SYMBOL replace_substrings(std::string& in, std::string_view const& find, std::string_view const& replacement);
bool FZ_PUBLIC_SYMBOL replace_substrings(std::wstring& in, std::wstring_view const& find, std::wstring_view const& replacement);
 
bool FZ_PUBLIC_SYMBOL replace_substrings(std::string& in, char find, char replacement);
bool FZ_PUBLIC_SYMBOL replace_substrings(std::wstring& in, wchar_t find, wchar_t replacement);
 
template <typename String, typename Delims>
class strtokenizer
{
    using view_type = std::basic_string_view<std::decay_t<decltype(std::declval<String>()[0])>>;
 
public:
    constexpr strtokenizer(String && string, Delims &&delims, bool ignore_empty)
        : string_(std::forward<String>(string))
        , delims_(std::forward<Delims>(delims))
        , ignore_empty_(ignore_empty)
    {}
 
    using value_type = const view_type;
    using pointer = value_type*;
    using reference = value_type&;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
 
    struct sentinel{};
 
    struct iterator
    {
        using iterator_category = std::input_iterator_tag;
        using difference_type   = strtokenizer::difference_type;
        using value_type        = strtokenizer::value_type;
        using pointer           = strtokenizer::pointer;
        using reference         = strtokenizer::reference;
 
        constexpr bool operator !=(sentinel) const
        {
            return !s_.empty();
        }
 
        constexpr bool operator ==(sentinel) const
        {
            return s_.empty();
        }
 
        constexpr value_type operator*() const
        {
            return s_.substr(0, pos_);
        }
 
        constexpr iterator &operator++()
        {
            for (;;) {
                if (pos_ != s_.size()) {
                    ++pos_;
                }
 
                s_.remove_prefix(pos_);
 
                pos_ = s_.find_first_of(t_->delims_);
 
                if (pos_ == view_type::npos) {
                    pos_ = s_.size();
                    break;
                }
 
                if (pos_ != 0 || !t_->ignore_empty_) {
                    break;
                }
            }
 
            return *this;
        }
 
    private:
        friend strtokenizer;
 
        constexpr iterator(const strtokenizer *t)
            : t_(t)
            , s_(view_type(t_->string_))
            , pos_(view_type::npos)
        {
            operator++();
        }
 
        const strtokenizer *t_;
        view_type s_;
        size_type pos_;
    };
 
    using const_value_type = value_type;
    using const_pointer = pointer;
    using const_reference = reference;
    using const_iterator = iterator;
 
    constexpr iterator begin() const
    {
        return { this };
    }
 
    constexpr sentinel end() const
    {
        return {};
    }
 
    constexpr const_iterator cbegin() const
    {
        return { this };
    }
 
    constexpr sentinel cend() const
    {
        return {};
    }
 
public:
    String string_;
    Delims delims_;
    bool ignore_empty_;
};
 
template <typename String, typename Delims>
strtokenizer(String && string, Delims &&delims, bool ignore_empty) -> strtokenizer<String, Delims>;
 
std::vector<std::string> FZ_PUBLIC_SYMBOL strtok(std::string_view const& tokens, std::string_view const& delims, bool const ignore_empty = true);
std::vector<std::wstring> FZ_PUBLIC_SYMBOL strtok(std::wstring_view const& tokens, std::wstring_view const& delims, bool const ignore_empty = true);
inline auto FZ_PUBLIC_SYMBOL strtok(std::string_view const& tokens, char const delim, bool const ignore_empty = true) {
    return strtok(tokens, std::string_view(&delim, 1), ignore_empty);
}
inline auto FZ_PUBLIC_SYMBOL strtok(std::wstring_view const& tokens, wchar_t const delim, bool const ignore_empty = true) {
    return strtok(tokens, std::wstring_view(&delim, 1), ignore_empty);
}
 
std::vector<std::string_view> FZ_PUBLIC_SYMBOL strtok_view(std::string_view const& tokens, std::string_view const& delims, bool const ignore_empty = true);
std::vector<std::wstring_view> FZ_PUBLIC_SYMBOL strtok_view(std::wstring_view const& tokens, std::wstring_view const& delims, bool const ignore_empty = true);
inline auto FZ_PUBLIC_SYMBOL strtok_view(std::string_view const& tokens, char const delim, bool const ignore_empty = true) {
    return strtok_view(tokens, std::string_view(&delim, 1), ignore_empty);
}
inline auto FZ_PUBLIC_SYMBOL strtok_view(std::wstring_view const& tokens, wchar_t const delim, bool const ignore_empty = true) {
    return strtok_view(tokens, std::wstring_view(&delim, 1), ignore_empty);
}
 
template<typename T, typename String>
T to_integral_impl(String const& s, T const errorval = T())
{
    if constexpr (std::is_same_v<T, bool>) {
        return static_cast<T>(to_integral_impl<unsigned int>(s, static_cast<unsigned int>(errorval))) != 0;
    }
    else if constexpr (std::is_enum_v<T>) {
        return static_cast<T>(to_integral_impl<std::underlying_type_t<T>>(s, static_cast<std::underlying_type_t<T>>(errorval)));
    }
    else {
        T ret{};
        auto it = s.cbegin();
        if (it != s.cend() && (*it == '-' || *it == '+')) {
            ++it;
        }
 
        if (it == s.cend()) {
            return errorval;
        }
 
        for (; it != s.cend(); ++it) {
            auto const& c = *it;
            if (c < '0' || c > '9') {
                return errorval;
            }
            ret *= 10;
            ret += c - '0';
        }
 
        if (!s.empty() && s.front() == '-') {
            ret *= static_cast<T>(-1);
        }
        return ret;
    }
}
 
template<typename T>
T to_integral(std::string_view const& s, T const errorval = T()) {
    return to_integral_impl<T>(s, errorval);
}
 
template<typename T>
T to_integral(std::wstring_view const& s, T const errorval = T()) {
    return to_integral_impl<T>(s, errorval);
}
 
template<typename T, typename StringType>
T to_integral(std::basic_string_view<StringType> const& s, T const errorval = T()) {
    return to_integral_impl<T>(s, errorval);
}
 
 
template<typename String>
bool str_is_ascii(String const& s) {
    for (auto const& c : s) {
        if (static_cast<std::make_unsigned_t<typename String::value_type>>(c) > 127) {
            return false;
        }
    }
 
    return true;
}
 
template<typename String, typename Chars>
void trim_impl(String & s, Chars const& chars, bool fromLeft, bool fromRight) {
    size_t const first = fromLeft ? s.find_first_not_of(chars) : 0;
    if (first == String::npos) {
        s = String();
        return;
    }
 
    size_t const last = fromRight ? s.find_last_not_of(chars) : s.size();
    if (last == String::npos) {
        s = String();
        return;
    }
 
    // Invariant: If first exists, then last >= first
    s = s.substr(first, last - first + 1);
}
 
inline std::string FZ_PUBLIC_SYMBOL trimmed(std::string_view s, std::string_view const& chars = " \r\n\t", bool fromLeft = true, bool fromRight = true)
{
    trim_impl(s, chars, fromLeft, fromRight);
    return std::string(s);
}
 
inline std::wstring FZ_PUBLIC_SYMBOL trimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t", bool fromLeft = true, bool fromRight = true)
{
    trim_impl(s, chars, fromLeft, fromRight);
    return std::wstring(s);
}
 
inline std::string FZ_PUBLIC_SYMBOL ltrimmed(std::string_view s, std::string_view const& chars = " \r\n\t")
{
    trim_impl(s, chars, true, false);
    return std::string(s);
}
 
inline std::wstring FZ_PUBLIC_SYMBOL ltrimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t")
{
    trim_impl(s, chars, true, false);
    return std::wstring(s);
}
 
inline std::string FZ_PUBLIC_SYMBOL rtrimmed(std::string_view s, std::string_view const& chars = " \r\n\t")
{
    trim_impl(s, chars, false, true);
    return std::string(s);
}
 
inline std::wstring FZ_PUBLIC_SYMBOL rtrimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t")
{
    trim_impl(s, chars, false, true);
    return std::wstring(s);
}
 
 
template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, char>, int> = 0>
inline void trim(String & s, std::string_view const& chars = " \r\n\t", bool fromLeft = true, bool fromRight = true)
{
    trim_impl(s, chars, fromLeft, fromRight);
}
 
template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
inline void trim(String & s, std::wstring_view const& chars = L" \r\n\t", bool fromLeft = true, bool fromRight = true)
{
    trim_impl(s, chars, fromLeft, fromRight);
}
 
template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, char>, int> = 0>
inline void ltrim(String& s, std::string_view const& chars = " \r\n\t")
{
    trim_impl(s, chars, true, false);
}
 
template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
inline void ltrim(String& s, std::wstring_view  const& chars = L" \r\n\t")
{
    trim_impl(s, chars, true, false);
}
 
template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, char>, int> = 0>
inline void rtrim(String& s, std::string_view const& chars = " \r\n\t")
{
    trim_impl(s, chars, false, true);
}
 
template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
inline void rtrim(String & s, std::wstring_view const& chars = L" \r\n\t")
{
    trim_impl(s, chars, false, true);
}
 
template<bool insensitive_ascii = false, typename String>
bool starts_with(String const& s, String const& beginning)
{
    if (beginning.size() > s.size()) {
        return false;
    }
    if constexpr (insensitive_ascii) {
        return std::equal(beginning.begin(), beginning.end(), s.begin(), [](typename String::value_type const& a, typename String::value_type const& b) {
            return tolower_ascii(a) == tolower_ascii(b);
        });
    }
    else {
        return std::equal(beginning.begin(), beginning.end(), s.begin());
    }
}
 
template<bool insensitive_ascii = false, typename String>
bool ends_with(String const& s, String const& ending)
{
    if (ending.size() > s.size()) {
        return false;
    }
 
    if constexpr (insensitive_ascii) {
        return std::equal(ending.rbegin(), ending.rend(), s.rbegin(), [](typename String::value_type const& a, typename String::value_type const& b) {
            return tolower_ascii(a) == tolower_ascii(b);
        });
    }
    else {
        return std::equal(ending.rbegin(), ending.rend(), s.rbegin());
    }
}
 
std::string FZ_PUBLIC_SYMBOL normalize_hyphens(std::string_view const& in);
std::wstring FZ_PUBLIC_SYMBOL normalize_hyphens(std::wstring_view const& in);
 
bool FZ_PUBLIC_SYMBOL is_valid_utf8(std::string_view s);
 
bool FZ_PUBLIC_SYMBOL is_valid_utf8(std::string_view s, size_t & state);
 
void FZ_PUBLIC_SYMBOL unicode_codepoint_to_utf8_append(std::string& result, uint32_t codepoint);
 
bool FZ_PUBLIC_SYMBOL utf16be_to_utf8_append(std::string & result, std::string_view data, uint32_t & state);
 
bool FZ_PUBLIC_SYMBOL utf16le_to_utf8_append(std::string & result, std::string_view data, uint32_t & state);
 
inline native_string to_native_from_utf8(std::string_view s) {
#ifdef FZ_WINDOWS
    return to_wstring_from_utf8(s);
#else
    return to_string(to_wstring_from_utf8(s));
#endif
}
 
}
 
#endif