encode.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_ENCODE_HEADER
#define LIBFILEZILLA_ENCODE_HEADER
 
#include "libfilezilla.hpp"
 
#include <string>
#include <vector>
 
namespace fz {
class buffer;
 
template<typename Char>
int hex_char_to_int(Char c)
{
    if (c >= 'a' && c <= 'f') {
        return c - 'a' + 10;
    }
    if (c >= 'A' && c <= 'F') {
        return c - 'A' + 10;
    }
    else if (c >= '0' && c <= '9') {
        return c - '0';
    }
    return -1;
}
 
template<typename OutString, typename String>
OutString hex_decode_impl(String const& in)
{
    OutString 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 OutString();
            }
            ret.push_back(static_cast<typename OutString::value_type>((high << 4) + low));
        }
    }
 
    return ret;
}
 
template<typename OutString = std::vector<uint8_t>>
OutString hex_decode(std::string_view const& in)
{
    return hex_decode_impl<OutString>(in);
}
 
template<typename OutString = std::vector<uint8_t>>
OutString hex_decode(std::wstring_view const& in)
{
    return hex_decode_impl<OutString>(in);
}
 
template<typename Char = char, bool Lowercase = true>
Char int_to_hex_char(int d)
{
    if (d > 9) {
        return static_cast<Char>((Lowercase ? 'a' : 'A') + d - 10);
    }
    else {
        return static_cast<Char>('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;
}
 
enum class base64_type {
    standard,
    url
};
 
std::string FZ_PUBLIC_SYMBOL base64_encode(std::string_view const& in, base64_type type = base64_type::standard, bool pad = true);
std::string FZ_PUBLIC_SYMBOL base64_encode(std::vector<uint8_t> const& in, base64_type type = base64_type::standard, bool pad = true);
std::string FZ_PUBLIC_SYMBOL base64_encode(fz::buffer const& in, base64_type type = base64_type::standard, bool pad = true);
 
void FZ_PUBLIC_SYMBOL base64_encode_append(std::string& result, std::string_view const& in, base64_type type = base64_type::standard, bool pad = true);
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL base64_decode(std::string_view const& in);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL base64_decode(std::wstring_view const& in);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL base64_decode(fz::buffer const& in);
std::string FZ_PUBLIC_SYMBOL base64_decode_s(std::string_view const& in);
std::string FZ_PUBLIC_SYMBOL base64_decode_s(std::wstring_view const& in);
std::string FZ_PUBLIC_SYMBOL base64_decode_s(fz::buffer const& in);
 
 
enum class base32_type {
    standard,
    base32hex,
    locale_safe
};
 
std::string FZ_PUBLIC_SYMBOL base32_encode(std::string_view const& in, base32_type type = base32_type::standard, bool pad = true);
std::string FZ_PUBLIC_SYMBOL base32_encode(std::vector<uint8_t> const& in, base32_type type = base32_type::standard, bool pad = true);
std::string FZ_PUBLIC_SYMBOL base32_encode(fz::buffer const& in, base32_type type = base32_type::standard, bool pad = true);
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL base32_decode(std::string_view const& in, base32_type type = base32_type::standard);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL base32_decode(std::wstring_view const& in, base32_type type = base32_type::standard);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL base32_decode(fz::buffer const& in, base32_type type = base32_type::standard);
std::string FZ_PUBLIC_SYMBOL base32_decode_s(std::string_view const& in, base32_type type = base32_type::standard);
std::string FZ_PUBLIC_SYMBOL base32_decode_s(std::wstring_view const& in, base32_type type = base32_type::standard);
std::string FZ_PUBLIC_SYMBOL base32_decode_s(fz::buffer const& in, base32_type type = base32_type::standard);
 
std::string FZ_PUBLIC_SYMBOL percent_encode(std::string_view const& s, bool keep_slashes = false);
std::string FZ_PUBLIC_SYMBOL percent_encode(std::wstring_view const& s, bool keep_slashes = false);
 
std::wstring FZ_PUBLIC_SYMBOL percent_encode_w(std::wstring_view const& s, bool keep_slashes = false);
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL percent_decode(std::string_view const& s, bool allow_embedded_null = false);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL percent_decode(std::wstring_view const& s, bool allow_embedded_null = false);
std::string FZ_PUBLIC_SYMBOL percent_decode_s(std::string_view const& s, bool allow_embedded_null = false);
std::string FZ_PUBLIC_SYMBOL percent_decode_s(std::wstring_view const& s, bool allow_embedded_null = false);
 
}
 
#endif