{

if (('0' <= hex_char) && (hex_char <= '9'))

return hex_char - '0';

else if (('A' <= hex_char) && (hex_char <= 'F'))

return hex_char - 'A' + 10;

else if (('a' <= hex_char) && (hex_char <= 'f'))

return hex_char - 'a' + 10;

else

throw std::out_of_range("should be A-Z a-z 0-9");

{

const auto& special_chars = path_mode ? path_special_chars : full_special_chars;

std::string url_str;

url_str.reserve(local_str.size() * 5 / 4); //! 预留1.25倍的空间

for (char c : local_str) {

//! 如果非ASCII或是特殊字符

if (c >= 128 || special_chars.find(c) != std::string::npos) {

url_str.push_back('%');

url_str.push_back(char_to_hex[c >> 4]);

url_str.push_back(char_to_hex[c & 0xf]);

} else

url_str.push_back(c);

}

return url_str;

{

std::string local_str;

local_str.reserve(url_str.size());

enum class State {

kNone,

kStart,

kHalfHex,

};

char tmp = 0;

State state = State::kNone;

for (char c : url_str) {

if (state == State::kNone) {

if (c == '%') {

state = State::kStart;

tmp = 0;

} else

local_str.push_back(c);

} else {

if (state == State::kStart) {

tmp = HexCharToValue(c) << 4;

state = State::kHalfHex;

} else if (state == State::kHalfHex) {

tmp |= HexCharToValue(c);

state = State::kNone;

local_str.push_back(tmp);

}

}

}

return local_str;

{

std::ostringstream oss;

if (!host.user.empty()) {

oss << host.user;

if (!host.password.empty())

oss << ':' << host.password;

oss << '@';

}

oss << host.host;

if (host.port != 0)

oss << ':' << host.port;

return oss.str();

{

std::ostringstream oss;

oss << UrlEncode(path.path, true);

for (const auto &item : path.params)

oss << ';' << UrlEncode(item.first) << '=' << UrlEncode(item.second);

if (!path.query.empty()) {

oss << '?';

bool not_first = false;

for (const auto &item : path.query) {

if (not_first)

oss << '&';

not_first = true;

oss << UrlEncode(item.first) << '=' << UrlEncode(item.second);

}

}

if (!path.frag.empty())

oss << '#' << path.frag;

return oss.str();

{

std::ostringstream oss;

if (!url.scheme.empty())

oss << url.scheme << "://";

oss << UrlHostToString(url.host);

oss << UrlPathToString(url.path);

return oss.str();

{

auto pos = str.find("://");

if (pos != std::string::npos) {

url.scheme = str.substr(0, pos);

pos += 3;

} else {

pos = 0;

}

std::string host_str;

std::string path_str;

//! 将剩下的 url 拆分成两部分 host + path，分别进行解析

auto path_start_pos = str.find_first_of('/', pos);

if (path_start_pos != std::string::npos) {

host_str = str.substr(pos, path_start_pos - pos);

path_str = str.substr(path_start_pos);

} else {

host_str = str.substr(pos);

path_str = "/";

}

return StringToUrlHost(host_str, url.host) &&

StringToUrlPath(path_str, url.path);

{

//! 解析：<user>:<password>@<host>:<port>

//! 先找@。如果找到了，就分成 user:password 与 host:port 两部分

//! 如果没有找到，则说明只有 host:port

auto at_pos = str.find_first_of('@');

auto host_start_pose = 0;

try {

if (at_pos != std::string::npos) {

auto colon_pos = str.find_first_of(':');

if (colon_pos == std::string::npos || colon_pos > at_pos) {

//! 说明没有 password

host.user = UrlDecode(str.substr(0, at_pos));

host.password.clear();

} else {

host.user = UrlDecode(str.substr(0, colon_pos));

host.password = UrlDecode(str.substr(colon_pos + 1, at_pos - colon_pos - 1));

}

host_start_pose = at_pos + 1;

}

auto colon_pos = str.find_first_of(':', host_start_pose);

if (colon_pos == std::string::npos) {

//! 说明没有 password

host.host = UrlDecode(str.substr(host_start_pose));

host.port = 0;

} else {

host.host = UrlDecode(str.substr(host_start_pose, colon_pos - host_start_pose));

host.port = std::stoi(str.substr(colon_pos + 1));

}

} catch (const std::exception &) {

return false;

}

return true;

{

//! /<path>;<params>?<query>#<frag>

if (str.empty() || str[0] != '/')

return false;

auto semi_pos = str.find_first_of(';');

auto query_pos = str.find_first_of('?');

auto pound_pos = str.find_first_of('#');

auto path_end_pos = std::string::npos;

if (semi_pos != std::string::npos)

path_end_pos = semi_pos;

else if (query_pos != std::string::npos)

path_end_pos = query_pos;

else if (pound_pos != std::string::npos)

path_end_pos = pound_pos;

try {

path.path = UrlDecode(str.substr(0, path_end_pos));

if (semi_pos != std::string::npos) {

//! 说明有 params

auto params_end_pos = std::string::npos;

if (query_pos != std::string::npos)

params_end_pos = query_pos;

else if (pound_pos != std::string::npos)

params_end_pos = pound_pos;

auto params_str = str.substr(semi_pos + 1, params_end_pos - semi_pos - 1);

std::vector<std::string> params_vec;

util::string::Split(params_str, ";", params_vec);

for (const auto &param_str : params_vec) {

std::vector<std::string> kv;

util::string::Split(param_str, "=", kv);

if (kv.size() != 2 || kv[0].empty())

return false;

path.params[UrlDecode(kv[0])] = UrlDecode(kv[1]);

}

}

if (query_pos != std::string::npos) {

//! 说明有 query

auto querys_end_pos = std::string::npos;

if (pound_pos != std::string::npos)

querys_end_pos = pound_pos;

auto querys_str = str.substr(query_pos + 1, querys_end_pos - query_pos - 1);

std::vector<std::string> querys_vec;

util::string::Split(querys_str, "&", querys_vec);

for (const auto &query_str : querys_vec) {

std::vector<std::string> kv;

util::string::Split(query_str, "=", kv);

if (kv.size() != 2 || kv[0].empty())

return false;

path.query[UrlDecode(kv[0])] = UrlDecode(kv[1]);

}

}

if (pound_pos != std::string::npos) {

//! 说明有 frag

path.frag = UrlDecode(str.substr(pound_pos + 1));

}

} catch (const std::exception &) {

return false;

}

return true;