string.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_STRING_HEADER
#define LIBFILEZILLA_STRING_HEADER

#include "libfilezilla.hpp"

#include <string>
#include <vector>

namespace fz {

#ifdef FZ_WINDOWS
typedef std::wstring native_string;
#endif
#if defined(FZ_UNIX) || defined(FZ_MAC)
typedef std::string native_string;
#endif

native_string FZ_PUBLIC_SYMBOL to_native(std::string const& in);

native_string FZ_PUBLIC_SYMBOL to_native(std::wstring const& in);

int FZ_PUBLIC_SYMBOL stricmp(std::string const& a, std::string const& b);
int FZ_PUBLIC_SYMBOL stricmp(std::wstring const& a, std::wstring 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!
template<typename String>
String str_tolower_ascii(String const& s)
{
    String ret = s;
    for (auto& c : ret) {
        c = tolower_ascii(c);
    }
    return ret;
}

template<typename String>
String str_toupper_ascii(String const& s)
{
    String ret = s;
    for (auto& c : ret) {
        c = toupper_ascii(c);
    }
    return ret;
}

std::wstring FZ_PUBLIC_SYMBOL to_wstring(std::string const& in);

inline std::wstring FZ_PUBLIC_SYMBOL to_wstring(std::wstring const& in) { return in; }

template<typename Arg>
inline typename std::enable_if<std::is_arithmetic<std::decay_t<Arg>>::value, 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 const& in);

std::string FZ_PUBLIC_SYMBOL to_string(std::wstring const& in);

inline std::string FZ_PUBLIC_SYMBOL to_string(std::string const& in) { return in; }

template<typename Arg>
inline typename std::enable_if<std::is_arithmetic<std::decay_t<Arg>>::value, 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 const& in);

std::string FZ_PUBLIC_SYMBOL to_utf8(std::wstring const& in);


template<typename Char>
int hex_char_to_int(Char c)
{
    if (c >= 'a' && c <= 'z') {
        return c - 'a' + 10;
    }
    if (c >= 'A' && c <= 'Z') {
        return c - 'A' + 10;
    }
    else if (c >= '0' && c <= '9') {
        return c - '0';
    }
    return -1;
}

template<typename String>
std::vector<uint8_t> hex_decode(String const& in)
{
    std::vector<uint8_t> ret;
    if (!(in.size() % 2)) {
        ret.reserve(in.size() / 2);
        for (size_t i = 0; i < in.size(); i += 2) {
            int high = hex_char_to_int(in[i]);
            int low = hex_char_to_int(in[i + 1]);
            if (high == -1 || low == -1) {
                return std::vector<uint8_t>();
            }
            ret.push_back(static_cast<uint8_t>((high << 4) + low));
        }
    }

    return ret;
}

template<typename Char = char, bool Lowercase = true>
Char int_to_hex_char(int d)
{
    if (d > 9) {
        return (Lowercase ? 'a' : 'A') + d - 10;
    }
    else {
        return '0' + d;
    }
}

template<typename String, typename InString, bool Lowercase = true>
String hex_encode(InString const& data)
{
    static_assert(sizeof(typename InString::value_type) == 1, "Input must be a container of 8 bit values");
    String ret;
    ret.reserve(data.size() * 2);
    for (auto const& c : data) {
        ret.push_back(int_to_hex_char<typename String::value_type, Lowercase>(static_cast<unsigned char>(c) >> 4));
        ret.push_back(int_to_hex_char<typename String::value_type, Lowercase>(static_cast<unsigned char>(c) & 0xf));
    }

    return ret;
}

template<typename String, typename Arg>
inline auto toString(Arg&& arg) -> typename std::enable_if<std::is_same<String, std::string>::value, 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<String, std::wstring>::value, 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 const& in, std::string const& find, std::string const& replacement);
std::wstring FZ_PUBLIC_SYMBOL replaced_substrings(std::wstring const& in, std::wstring const& find, std::wstring const& replacement);

void FZ_PUBLIC_SYMBOL replace_substrings(std::string& in, std::string const& find, std::string const& replacement);
void FZ_PUBLIC_SYMBOL replace_substrings(std::wstring& in, std::wstring const& find, std::wstring const& replacement);

template<typename String, typename Delim, typename Container = std::vector<String>>
Container strtok(String const& s, Delim const& delims)
{
    Container ret;

    typename String::size_type start{}, pos{};
    do {
        pos = s.find_first_of(delims, start);

        // Not found, we're at ends;
        if (pos == String::npos) {
            if (start + 1 < s.size()) {
                ret.emplace_back(s.substr(start));
            }
        }
        else if (pos > start + 1) {
            // Non-empty substring
            ret.emplace_back(s.substr(start, pos - start));
        }
        start = pos + 1;
    } while (pos != String::npos);

    return ret;
}


std::string FZ_PUBLIC_SYMBOL base64_encode(std::string const& in);

std::string FZ_PUBLIC_SYMBOL base64_decode(std::string const& in);

// Converts string to integral type T. If string is not convertible, T() is returned.
template<typename T, typename String>
T to_integral(String const& s, T const errorval = T())
{
    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() == '-') {
        return ret *= static_cast<T>(-1);
    }
    else {
        return ret;
    }
}

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>
String trimmed(String const& s) {
    size_t const first = s.find_first_not_of(fzS(typename String::value_type, " \r\n\t"));
    if (first == String::npos) {
        return String();
    }
    else {
        // Cannot be npos
        size_t const last = s.find_last_not_of(fzS(typename String::value_type, " \r\n\t"));

        return s.substr(first, last - first + 1);
    }
}


template<typename String>
void trim(String & s) {
    s = trimmed(s);
}

}

#endif