uri.h

Go to the documentation of this file.

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef MOD_SERVLET_URI_H
#define MOD_SERVLET_URI_H

#include <string>
#include <iostream>
#include <iterator>
#include <vector>
#include <functional>
#include <experimental/string_view>

#include <servlet/lib/exception.h>

namespace servlet
{

using std::experimental::string_view;

struct uri_syntax_error : public std::runtime_error
{
    using std::runtime_error::runtime_error;
};
struct uri_builder_error : public std::runtime_error
{
    using std::runtime_error::runtime_error;
};

class URI
{
public:
    typedef std::string string_type;

    typedef std::experimental::string_view string_view;

    typedef string_view::const_iterator const_iterator;

    URI() : _uri{}, _uri_view{_uri}, _scheme{_uri}, _user_info{_uri}, _host{_uri},
            _port{_uri}, _path{_uri}, _query{_uri}, _fragment{_uri} {}

    explicit URI(const string_type& uri_str) : _uri{uri_str} { _initialize(); }

    explicit URI(string_type&& uri_str) : _uri{std::move(uri_str)} { _initialize(); }

    explicit URI(string_view uri_str) : _uri{uri_str.to_string()} { _initialize(); }

    explicit URI(const char* uri_str) : _uri{uri_str} { _initialize(); }

    template <class InputIter>
    URI(InputIter first, InputIter last) : _uri{string_type(first, last)} { _initialize(); }

    URI(string_view scheme, string_view userInfo, string_view host, uint16_t port,
        string_view path, string_view query, string_view fragment);

    URI(string_view scheme, string_view host, uint16_t port, string_view path, string_view query) :
            URI{scheme, "", host, port, path, query, ""} {}

    URI(const URI &other) : _uri{other._uri}, _uri_view{_uri}, _normalized{other._normalized} { _move_parts(other); }

    URI(URI &&other) noexcept : _uri{std::move(other._uri)}, _uri_view{_uri} { _move_parts(other); }

    ~URI() noexcept {}

    URI &operator=(const URI& other);

    URI &operator=(URI&& other);

    URI &operator=(const string_type& uri_str) { _uri = uri_str; _initialize(); return *this; }

    URI &operator=(string_type&& uri_str) { _uri = std::move(uri_str); _initialize(); return *this; }

    URI &operator=(string_view uri_str) { _uri = uri_str.to_string(), _initialize(); return *this; }

    URI &operator=(const char* uri_str) { _uri = uri_str; _initialize(); return *this; }

    void swap(URI &other) noexcept;

    const_iterator begin() const noexcept { return _uri_view.begin(); }

    const_iterator end() const noexcept { return _uri_view.end(); }

    string_view scheme() const noexcept { return _scheme; }

    void set_scheme(string_view scheme);

    string_view user_info() const noexcept { return _user_info; }

    void set_user_info(string_view user_info);

    string_view host() const noexcept { return _host; }

    void set_host(string_view host);

    string_view port_view() const noexcept { return _port; }

    uint16_t port() const noexcept { return _port_i; }

    void set_port(string_view port);

    void set_port(uint16_t port);

    string_view path() const noexcept { return _path; }

    void set_path(string_view path);

    string_view query() const noexcept { return _query; }

    void set_query(string_view query);

    void add_to_query(string_view name, string_view value);

    void parse_query(std::function<void(std::string&&, std::string&&)> consumer)
    { parse_query(_query, consumer); }

    static void parse_query(string_view query, std::function<void(std::string&&, std::string&&)> consumer);

    string_view fragment() const noexcept { return _fragment; }

    void set_fragment(string_view fragment);

    bool has_authority() const noexcept;

    string_view authority() const noexcept;

    string_view uri_view() const noexcept { return _uri_view; }

    const std::string& string() const noexcept { return _uri; }

    std::string&& string_move() { return std::move(_uri); }

    std::string to_ASCII_string() const;

    bool empty() const noexcept { return _uri.empty(); }

    bool is_absolute() const noexcept { return !_scheme.empty(); }

    bool is_opaque() const noexcept; // { return (is_absolute() && !has_authority()); }

    void normalize_path();

    void normalize();

    URI create_normalized() const;

    URI create_with_normalized_path() const;

    URI relativize(const URI &uri) const;

    URI resolve(const URI &uri) const;

    int compare(const URI &other) const noexcept;

    static uint16_t get_default_port(string_view scheme);

    static std::string decode(string_view str);

private:
    void _initialize();
    void _initialize(string_view scheme, string_view user_info, string_view host, string_view port,
                     string_view path, string_view query, string_view fragment);

    void _parse(string_view::const_iterator &it, string_view::const_iterator last);
    bool _set_host_and_port(string_view::const_iterator first,
                            string_view::const_iterator last,
                            string_view::const_iterator last_colon);

    void _move_parts(const URI& other);
    void _resize_parts(std::size_t offset, int_fast16_t resize_bytes);
    void _decode_encoded_unreserved_chars();

    string_type _uri;
    string_view _uri_view;
    string_view _scheme;
    string_view _user_info;
    string_view _host;
    string_view _port;
    uint16_t    _port_i = 0;
    string_view _path;
    string_view _query;
    string_view _fragment;
    bool _normalized = false;

    static const std::vector<std::pair<std::string, uint16_t>> DEFAULT_PORTS;
};

template<typename CharT, typename Traits>
inline std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& out, const URI& uri)
{
    return out << uri.uri_view();
}

inline bool operator==(const URI& uri1, const URI& uri2) noexcept { return uri1.uri_view() == uri2.uri_view(); }

inline bool operator==(const URI& uri1, const URI::string_type& uri2) noexcept { return uri1.string() == uri2; }

inline bool operator==(const URI::string_type& uri1, const URI& uri2) noexcept { return uri1 == uri2.string(); }

inline bool operator==(const URI& uri1, const URI::string_view& uri2) noexcept { return uri1.uri_view() == uri2; }

inline bool operator==(const URI::string_view& uri1, const URI& uri2) noexcept { return uri1 == uri2.uri_view(); }

inline bool operator!=(const URI& uri1, const URI& uri2) noexcept { return uri1.uri_view() != uri2.uri_view(); }

inline bool operator!=(const URI& uri1, const URI::string_type& uri2) noexcept { return uri1.string() != uri2; }

inline bool operator!=(const URI::string_type& uri1, const URI& uri2) noexcept { return uri1 != uri2.string(); }

inline bool operator!=(const URI& uri1, const URI::string_view& uri2) noexcept { return uri1.uri_view() != uri2; }

inline bool operator!=(const URI::string_view& uri1, const URI& uri2) noexcept { return uri1 != uri2.uri_view(); }

inline bool operator<(const URI& uri1, const URI& uri2) noexcept { return uri1.uri_view() <  uri2.uri_view(); }

inline bool operator<(const URI& uri1, const URI::string_type& uri2) noexcept { return uri1.string() < uri2; }

inline bool operator<(const URI::string_type& uri1, const URI& uri2) noexcept { return uri1 < uri2.string(); }

inline bool operator<(const URI& uri1, const URI::string_view& uri2) noexcept { return uri1.uri_view() < uri2; }

inline bool operator<(const URI::string_view& uri1, const URI& uri2) noexcept { return uri1 < uri2.uri_view(); }

inline bool operator>(const URI& uri1, const URI& uri2) noexcept { return uri1.uri_view() >  uri2.uri_view(); }

inline bool operator>(const URI& uri1, const URI::string_type& uri2) noexcept { return uri1.string() > uri2; }

inline bool operator>(const URI::string_type& uri1, const URI& uri2) noexcept { return uri1 > uri2.string(); }

inline bool operator>(const URI& uri1, const URI::string_view& uri2) noexcept { return uri1.uri_view() > uri2; }

inline bool operator>(const URI::string_view& uri1, const URI& uri2) noexcept { return uri1 > uri2.uri_view(); }

inline bool operator<=(const URI& uri1, const URI& uri2) noexcept { return uri1.uri_view() <= uri2.uri_view(); }

inline bool operator<=(const URI& uri1, const URI::string_type& uri2) noexcept { return uri1.string() <= uri2; }

inline bool operator<=(const URI::string_type& uri1, const URI& uri2) noexcept { return uri1 <= uri2.string(); }

inline bool operator<=(const URI& uri1, const URI::string_view& uri2) noexcept { return uri1.uri_view() <= uri2; }

inline bool operator<=(const URI::string_view& uri1, const URI& uri2) noexcept { return uri1 <= uri2.uri_view(); }

inline bool operator>=(const URI& uri1, const URI& uri2) noexcept { return uri1.uri_view() >= uri2.uri_view(); }

inline bool operator>=(const URI& uri1, const URI::string_type& uri2) noexcept { return uri1.string() >= uri2; }

inline bool operator>=(const URI::string_type& uri1, const URI& uri2) noexcept { return uri1 >= uri2.string(); }

inline bool operator>=(const URI& uri1, const URI::string_view& uri2) noexcept { return uri1.uri_view() >= uri2; }

inline bool operator>=(const URI::string_view& uri1, const URI& uri2) noexcept { return uri1 >= uri2.uri_view(); }

inline void swap(URI &lhs, URI &rhs) noexcept { lhs.swap(rhs); }

} // end of servlet namespace

#endif // MOD_SERVLET_URI_H