uri.h

Go to the documentation of this file.

 
#include <charconv>
#include <qb/io/config.h>
#include <qb/system/container/unordered_map.h>
#include <qb/utility/build_macros.h>
#include <regex>
#include <string>
#include <string_view>
#include <vector>
 
#ifndef QB_IO_URI_H_
#define QB_IO_URI_H_
 
namespace qb::io {

inline bool
is_alnum(int c) {
    return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}

inline bool
is_unreserved(int c) {
    return is_alnum((char) c) || c == '-' || c == '.' || c == '_' || c == '~';
}

inline bool
is_gen_delim(int c) {
    return c == ':' || c == '/' || c == '?' || c == '#' || c == '[' || c == ']' ||
           c == '@';
}

inline bool
is_sub_delim(int c) {
    switch (c) {
        case '!':
        case '$':
        case '&':
        case '\'':
        case '(':
        case ')':
        case '*':
        case '+':
        case ',':
        case ';':
        case '=':
            return true;
        default:
            return false;
    }
}

inline bool
is_reserved(int c) {
    return is_gen_delim(c) || is_sub_delim(c);
}

inline bool
is_scheme_character(int c) {
    return is_alnum((char) c) || c == '+' || c == '-' || c == '.';
}

inline bool
is_user_info_character(int c) {
    return is_unreserved(c) || is_sub_delim(c) || c == '%' || c == ':';
}

inline bool
is_authority_character(int c) {
    return is_unreserved(c) || is_sub_delim(c) || c == '%' || c == '@' || c == ':' ||
           c == '[' || c == ']';
}

inline bool
is_path_character(int c) {
    return is_unreserved(c) || is_sub_delim(c) || c == '%' || c == '/' || c == ':' ||
           c == '@';
}

inline bool
is_query_character(int c) {
    return is_path_character(c) || c == '?';
}

inline bool
is_fragment_character(int c) {
    // this is intentional, they have the same set of legal characters
    return is_query_character(c);
}

class uri {
    int              _af = AF_INET; 
    std::string      _source;       
    std::string_view _scheme;       
    std::string_view _user_info;    
    std::string_view _host;         
    std::string_view _port;         
    std::string_view _path;         
    std::string_view _raw_queries;  
    std::string_view _fragment;     
    qb::icase_unordered_map<std::vector<std::string>>
        _queries; 
 
    constexpr static const char no_path[] = "/"; 
 
    bool parse_queries(std::size_t pos) noexcept; 
    //    bool parse_v6(std::size_t pos) noexcept;                /**< Parse an IPv6
    //    address */ bool parse_v4() noexcept;                               /**< Parse
    //    an IPv4 address */

    bool parse() noexcept;

    bool from(std::string const &rhs) noexcept;

    bool from(std::string &&rhs) noexcept;

    void parse_query_parameters(const char* begin, const char* end);
 
public:
    uri() = default;

    uri(uri &&rhs) noexcept;

    uri(uri const &rhs);

    uri(std::string const &str, int af = AF_INET);

    uri(std::string &&str, int af = AF_INET) noexcept;

    static const char tbl[256];

    template <typename _IT>
    static std::string
    decode(_IT begin, _IT end) noexcept {
        std::string out;
        char        c, v1, v2{};
 
        while (begin != end) {
            c = *(begin++);
            if (c == '%') {
                if ((v1 = tbl[(unsigned char) *(begin++)]) < 0 ||
                    (v2 = tbl[(unsigned char) *(begin++)]) < 0) {
                    break;
                }
                c = (v1 << 4) | v2;
            }
            out += (c);
        }
 
        return out;
    }

    constexpr static const char hex[] = "0123456789ABCDEF";

    template <typename _IT>
    static std::string
    encode(_IT begin, _IT end) noexcept {
        std::string encoded;
 
        encoded.reserve(static_cast<ptrdiff_t>(end - begin) * 3);
        for (auto iter = begin; iter != end; ++iter) {
            // for utf8 encoded string, char ASCII can be greater than 127.
            int ch = static_cast<unsigned char>(*iter);
            // ch should be same under both utf8 and utf16.
            if (!is_unreserved(ch) && !is_reserved(ch)) {
                encoded.push_back('%');
                encoded.push_back(hex[(ch >> 4) & 0xF]);
                encoded.push_back(hex[ch & 0xF]);
            } else {
                // ASCII don't need to be encoded, which should be same on both utf8 and
                // utf16.
                encoded.push_back((char) ch);
            }
        }
 
        return encoded;
    }

    static std::string decode(std::string_view input) noexcept;

    static std::string encode(std::string_view input) noexcept;

    static std::string decode(const char *input, std::size_t size) noexcept;

    static std::string encode(const char *input, std::size_t size) noexcept;

    static uri parse(std::string const &str, int af = AF_INET) noexcept;

    uri &operator=(uri const &rhs);

    uri &operator=(uri &&rhs) noexcept;

    uri &operator=(std::string const &str);

    uri &operator=(std::string &&str) noexcept;

    [[nodiscard]] inline auto
    af() const {
        return _af;
    }

    [[nodiscard]] inline const auto &
    source() const {
        return _source;
    }

    [[nodiscard]] inline auto
    scheme() const {
        return _scheme;
    }

    [[nodiscard]] inline auto
    user_info() const {
        return _user_info;
    }

    [[nodiscard]] inline auto
    host() const {
        return _host;
    }

    [[nodiscard]] inline auto
    port() const {
        return _port;
    }

    [[nodiscard]] uint16_t
    u_port() const {
        int p = 0;
 
        std::from_chars(port().data(), port().data() + port().size(), p);
        return static_cast<uint16_t>(p);
    }

    [[nodiscard]] inline auto
    path() const {
        return _path;
    }

    [[nodiscard]] inline const auto &
    encoded_queries() const {
        return _raw_queries;
    }

    [[nodiscard]] inline const auto &
    queries() const {
        return _queries;
    }

    [[nodiscard]] inline auto &
    queries() {
        return _queries;
    }

    template <typename T>
    [[nodiscard]] std::string const &
    query(T &&name, std::size_t const index = 0,
          std::string const &not_found = "") const {
        const auto &it = this->_queries.find(std::forward<T>(name));
        if (it != this->_queries.cend() && index < it->second.size())
            return it->second[index];
 
        return not_found;
    }

    [[nodiscard]] inline auto
    fragment() const {
        return _fragment;
    }

    static bool is_valid_scheme(std::string_view scheme) noexcept;

    static bool is_valid_host(std::string_view host) noexcept;

    static bool normalize_path(std::string &path) noexcept;
};
} // namespace qb::io
 
#endif // QB_IO_URI_H_