url_search_params.h

Go to the documentation of this file.

// Copyright 2016-2026 Rimas Misevičius
// Distributed under the BSD-style license that can be
// found in the LICENSE file.
//
 
#ifndef UPA_URL_SEARCH_PARAMS_H
#define UPA_URL_SEARCH_PARAMS_H
 
#include "config.h" // IWYU pragma: export
#include "str_arg.h"
#include "url_percent_encode.h"
#include "url_utf.h"
 
#ifndef UPA_MODULE
# include <cassert>
# include <list>
# include <memory>
# include <ostream>
# include <string>
# include <string_view>
# include <type_traits>
# include <utility>
#endif // UPA_MODULE
 
namespace upa {
 
namespace detail {
 
// is key value pair
template <typename>
constexpr bool is_pair_v = false;
 
template<class T1, class T2>
constexpr bool is_pair_v<std::pair<T1, T2>> = true;
 
// is iterable over the std::pair values
template<class T, typename = void>
constexpr bool is_iterable_pairs_v = false;
 
template<class T>
constexpr bool is_iterable_pairs_v<T, std::void_t<decltype(
    // https://stackoverflow.com/a/29634934
    std::begin(std::declval<T&>()) != std::end(std::declval<T&>()), // begin/end and operator !=
    ++std::declval<decltype(std::begin(std::declval<T&>()))&>(), // operator ++
    *std::begin(std::declval<T&>()) // operator *
    )>> = is_pair_v<remove_cvref_t<decltype(*std::begin(std::declval<T&>()))>>;
 
// enable if `Base` is not the base class of `T`
template<class Base, class T>
using enable_if_not_base_of_t = std::enable_if_t<
    !std::is_base_of_v<Base, std::decay_t<T>>, int>;
 
} // namespace detail
 
 
// forward declarations
 
namespace detail {
    class url_search_params_ptr;
} // namespace detail
 
UPA_EXPORT_BEGIN
 
class url;

class url_search_params
{
public:
    // types
    using name_value_pair = std::pair<std::string, std::string>;
    using name_value_list = std::list<name_value_pair>;
    using const_iterator = name_value_list::const_iterator;
    using const_reverse_iterator = name_value_list::const_reverse_iterator;
    using iterator = const_iterator;
    using reverse_iterator = const_reverse_iterator;
    using size_type = name_value_list::size_type;
    using value_type = name_value_pair;
 
    // Constructors

    url_search_params() = default;

    url_search_params(const url_search_params& other);

    url_search_params(url_search_params&& other)
        noexcept(std::is_nothrow_move_constructible_v<name_value_list>);

    template <class StrT, enable_if_str_arg_t<StrT> = 0>
    inline explicit url_search_params(StrT&& query)
        : params_(do_parse(true, std::forward<StrT>(query)))
    {}

    template<class ConT,
        // do not hide the copy and move constructors:
        detail::enable_if_not_base_of_t<url_search_params, ConT> = 0,
        std::enable_if_t<detail::is_iterable_pairs_v<ConT>, int> = 0
    >
    inline explicit url_search_params(ConT&& cont) {
        for (const auto& p : cont) {
            params_.emplace_back(make_string(p.first), make_string(p.second));
        }
    }

    ~url_search_params() = default;
 
    // Assignment

    url_search_params& operator=(const url_search_params& other);

    url_search_params& operator=(url_search_params&& other) noexcept;

    url_search_params& safe_assign(url_search_params&& other);
 
    // Operations

    void clear();

    void swap(url_search_params& other) noexcept;

    template <class StrT, enable_if_str_arg_t<StrT> = 0>
    void parse(StrT&& query);

    template <class TN, class TV>
    void append(TN&& name, TV&& value);

    template <class TN>
    void del(const TN& name);

    template <class TN, class TV>
    void del(const TN& name, const TV& value);

    template <class TN>
    size_type remove(const TN& name);

    template <class TN, class TV>
    size_type remove(const TN& name, const TV& value);

    template <class UnaryPredicate>
    size_type remove_if(UnaryPredicate p);

    template <class TN>
    [[nodiscard]] const std::string* get(const TN& name) const;

    template <class TN>
    [[nodiscard]] std::list<std::string> get_all(const TN& name) const;

    template <class TN>
    [[nodiscard]] bool has(const TN& name) const;

    template <class TN, class TV>
    [[nodiscard]] bool has(const TN& name, const TV& value) const;

    template <class TN, class TV>
    void set(TN&& name, TV&& value);

    void sort();

    void serialize(std::string& query) const;

    [[nodiscard]] std::string to_string() const;
 
    // Iterators

    [[nodiscard]] inline const_iterator begin() const noexcept { return params_.begin(); }

    [[nodiscard]] inline const_iterator cbegin() const noexcept { return params_.cbegin(); }

    [[nodiscard]] inline const_iterator end() const noexcept { return params_.end(); }

    [[nodiscard]] inline const_iterator cend() const noexcept { return params_.cend(); }

    [[nodiscard]] inline const_reverse_iterator rbegin() const noexcept { return params_.rbegin(); }

    [[nodiscard]] inline const_reverse_iterator crbegin() const noexcept { return params_.crbegin(); }

    [[nodiscard]] inline const_reverse_iterator rend() const noexcept { return params_.rend(); }

    [[nodiscard]] inline const_reverse_iterator crend() const noexcept { return params_.crend(); }
 
    // Capacity

    [[nodiscard]] inline bool empty() const noexcept { return params_.empty(); }

    [[nodiscard]] inline size_type size() const noexcept { return params_.size(); }
 
    // Utils

    template <class StrT, enable_if_str_arg_t<StrT> = 0>
    [[nodiscard]] static name_value_list do_parse(bool rem_qmark, StrT&& query);

    template <class StrT, enable_if_str_arg_t<StrT> = 0>
    static void urlencode(std::string& encoded, StrT&& value);
 
private:
    explicit url_search_params(url* url_ptr);
 
    void clear_params() noexcept;
    void copy_params(const url_search_params& other);
    void move_params(url_search_params&& other) noexcept;
    void parse_params(std::string_view query);
 
    void update();
 
    static UPA_API void urlencode_sv(std::string& encoded, std::string_view value);
 
    friend class url;
    friend class detail::url_search_params_ptr;
    friend std::ostream& operator<<(std::ostream& os, const url_search_params& usp);
 
private:
    name_value_list params_;
    bool is_sorted_ = false;
    url* url_ptr_ = nullptr;
};
 
UPA_EXPORT_END
 
namespace detail {
 
class url_search_params_ptr
{
public:
    constexpr url_search_params_ptr() noexcept = default;
 
    // copy constructor initializes to nullptr
    constexpr url_search_params_ptr(const url_search_params_ptr&) noexcept {}
    url_search_params_ptr& operator=(const url_search_params_ptr& other);
 
    // move constructor/assignment
    UPA_CONSTEXPR_23 url_search_params_ptr(url_search_params_ptr&& other) noexcept = default;
    UPA_CONSTEXPR_23 url_search_params_ptr& operator=(url_search_params_ptr&& other) noexcept = default;
 
    // destructor
    UPA_CONSTEXPR_23 ~url_search_params_ptr() = default;
 
    inline void init(url* url_ptr) {
        ptr_.reset(new url_search_params(url_ptr)); // NOLINT(cppcoreguidelines-owning-memory)
    }
 
    inline void set_url_ptr(url* url_ptr) noexcept {
        if (ptr_)
            ptr_->url_ptr_ = url_ptr;
    }
 
    inline void clear_params() noexcept {
        assert(ptr_);
        ptr_->clear_params();
    }
    inline void parse_params(std::string_view query) {
        assert(ptr_);
        ptr_->parse_params(query);
    }
 
    UPA_CONSTEXPR_23 explicit operator bool() const noexcept {
        return static_cast<bool>(ptr_);
    }
    UPA_CONSTEXPR_23 url_search_params& operator*() const {
        return *ptr_;
    }
    UPA_CONSTEXPR_23 url_search_params* operator->() const noexcept {
        return ptr_.get();
    }
private:
    std::unique_ptr<url_search_params> ptr_;
};
 
} // namespace detail
 
 
// url_search_params inline
 
// Copy constructor
 
inline url_search_params::url_search_params(const url_search_params& other)
    : params_(other.params_)
    , is_sorted_(other.is_sorted_)
{}
 
// Move constructor
 
inline url_search_params::url_search_params(url_search_params&& other)
    noexcept(std::is_nothrow_move_constructible_v<name_value_list>)
    : params_(std::move(other.params_))
    , is_sorted_(other.is_sorted_)
{}
 
// Assignment
 
inline url_search_params& url_search_params::operator=(const url_search_params& other) {
    if (this != std::addressof(other)) {
        copy_params(other);
        update();
    }
    return *this;
}
 
inline url_search_params& url_search_params::operator=(url_search_params&& other) noexcept {
    assert(url_ptr_ == nullptr);
    move_params(std::move(other));
    return *this;
}
 
inline url_search_params& url_search_params::safe_assign(url_search_params&& other) {
    move_params(std::move(other));
    update();
    return *this;
}
 
// Operations
 
inline void url_search_params::clear() {
    params_.clear();
    is_sorted_ = true;
    update();
}
 
inline void url_search_params::swap(url_search_params& other) noexcept {
    assert(url_ptr_ == nullptr && other.url_ptr_ == nullptr);
 
    using std::swap;
 
    swap(params_, other.params_);
    swap(is_sorted_, other.is_sorted_);
}
 
inline void url_search_params::clear_params() noexcept {
    params_.clear();
    is_sorted_ = true;
}
 
inline void url_search_params::copy_params(const url_search_params& other) {
    params_ = other.params_;
    is_sorted_ = other.is_sorted_;
}
 
inline void url_search_params::move_params(url_search_params&& other) noexcept {
    params_ = std::move(other.params_);
    is_sorted_ = other.is_sorted_;
}
 
inline void url_search_params::parse_params(std::string_view query) {
    params_ = do_parse(false, query);
    is_sorted_ = false;
}
 
template <class StrT, enable_if_str_arg_t<StrT>>
inline void url_search_params::parse(StrT&& query) {
    params_ = do_parse(true, std::forward<StrT>(query));
    is_sorted_ = false;
    update();
}
 
template <class TN, class TV>
inline void url_search_params::append(TN&& name, TV&& value) {
    params_.emplace_back(
        make_string(std::forward<TN>(name)),
        make_string(std::forward<TV>(value))
    );
    is_sorted_ = false;
    update();
}
 
template <class TN>
inline void url_search_params::del(const TN& name) {
    const auto str_name = make_string(name);
 
    params_.remove_if([&](const value_type& item) {
        return item.first == str_name;
    });
    update();
}
 
template <class TN, class TV>
inline void url_search_params::del(const TN& name, const TV& value) {
    const auto str_name = make_string(name);
    const auto str_value = make_string(value);
 
    params_.remove_if([&](const value_type& item) {
        return item.first == str_name && item.second == str_value;
    });
    update();
}
 
template <class TN>
inline url_search_params::size_type url_search_params::remove(const TN& name) {
    const auto str_name = make_string(name);
 
    return remove_if([&](const value_type& item) {
        return item.first == str_name;
    });
}
 
template <class TN, class TV>
inline url_search_params::size_type url_search_params::remove(const TN& name, const TV& value) {
    const auto str_name = make_string(name);
    const auto str_value = make_string(value);
 
    return remove_if([&](const value_type& item) {
        return item.first == str_name && item.second == str_value;
    });
}
 
template <class UnaryPredicate>
inline url_search_params::size_type url_search_params::remove_if(UnaryPredicate p) {
#ifdef __cpp_lib_list_remove_return_type
    const size_type count = params_.remove_if(p);
#else
    const size_type old_size = params_.size();
    params_.remove_if(p);
    const size_type count = old_size - params_.size();
#endif
    if (count) update();
    return count;
}
 
template <class TN>
inline const std::string* url_search_params::get(const TN& name) const {
    const auto str_name = make_string(name);
    for (const auto& p : params_) {
        if (p.first == str_name)
            return &p.second;
    }
    return nullptr;
}
 
template <class TN>
inline std::list<std::string> url_search_params::get_all(const TN& name) const {
    std::list<std::string> lst;
    const auto str_name = make_string(name);
    for (const auto& p : params_) {
        if (p.first == str_name)
            lst.push_back(p.second);
    }
    return lst;
}
 
template <class TN>
inline bool url_search_params::has(const TN& name) const {
    const auto str_name = make_string(name);
    for (const auto& p : params_) {
        if (p.first == str_name)
            return true;
    }
    return false;
}
 
template <class TN, class TV>
inline bool url_search_params::has(const TN& name, const TV& value) const {
    const auto str_name = make_string(name);
    const auto str_value = make_string(value);
 
    for (const auto& p : params_) {
        if (p.first == str_name && p.second == str_value)
            return true;
    }
    return false;
}
 
template <class TN, class TV>
inline void url_search_params::set(TN&& name, TV&& value) {
    auto str_name = make_string(std::forward<TN>(name));
    auto str_value = make_string(std::forward<TV>(value));
 
    bool is_match = false;
    for (auto it = params_.begin(); it != params_.end(); ) {
        if (it->first == str_name) {
            if (is_match) {
                it = params_.erase(it);
                continue;
            }
            it->second = std::move(str_value);
            is_match = true;
        }
        ++it;
    }
    if (!is_match)
        append(std::move(str_name), std::move(str_value));
    else
        update();
}
 
inline void url_search_params::sort() {
    // https://url.spec.whatwg.org/#dom-urlsearchparams-sort
    // Sorting must be done by comparison of code units. The relative order
    // between name-value pairs with equal names must be preserved.
    if (!is_sorted_) {
        // https://en.cppreference.com/w/cpp/container/list/sort
        // std::list::sort preserves the order of equal elements.
        params_.sort([](const name_value_pair& a, const name_value_pair& b) {
            //return a.first < b.first;
            return url_utf::compare_by_code_units(
                a.first.data(), a.first.data() + a.first.size(),
                b.first.data(), b.first.data() + b.first.size()) < 0;
        });
        is_sorted_ = true;
    }
    update();
}
 
template <class StrT, enable_if_str_arg_t<StrT>>
inline url_search_params::name_value_list url_search_params::do_parse(bool rem_qmark, StrT&& query) {
    name_value_list lst;
 
    const auto str_query = make_string(std::forward<StrT>(query));
    auto b = str_query.begin();
    const auto e = str_query.end();
 
    // remove leading question-mark?
    if (rem_qmark && b != e && *b == '?')
        ++b;
 
    std::string name;
    std::string value;
    std::string* pval = &name;
    auto start = b;
    for (auto it = b; it != e; ++it) {
        switch (*it) {
        case '=':
            if (pval != &value)
                pval = &value;
            else
                pval->push_back(*it);
            break;
        case '&':
            if (start != it) {
                url_utf::check_fix_utf8(name);
                url_utf::check_fix_utf8(value);
                lst.emplace_back(std::move(name), std::move(value));
                // clear after move
                name.clear();
                value.clear();
            }
            pval = &name;
            start = it + 1; // skip '&'
            break;
        case '+':
            pval->push_back(' ');
            break;
        case '%':
            if (std::distance(it, e) > 2) {
                auto itc = it;
                const auto uc1 = static_cast<unsigned char>(*(++itc));
                const auto uc2 = static_cast<unsigned char>(*(++itc));
                if (detail::is_hex_char(uc1) && detail::is_hex_char(uc2)) {
                    const char c = static_cast<char>((detail::hex_char_to_num(uc1) << 4) + detail::hex_char_to_num(uc2));
                    pval->push_back(c);
                    it = itc;
                    break;
                }
            }
            [[fallthrough]];
        default:
            pval->push_back(*it);
            break;
        }
    }
    if (start != e) {
        url_utf::check_fix_utf8(name);
        url_utf::check_fix_utf8(value);
        lst.emplace_back(std::move(name), std::move(value));
    }
    return lst;
}
 
template <class StrT, enable_if_str_arg_t<StrT>>
inline void url_search_params::urlencode(std::string& encoded, StrT&& value) {
    const auto str_value = make_string(std::forward<StrT>(value));
    urlencode_sv(encoded, str_value);
}
 
inline void url_search_params::serialize(std::string& query) const {
    auto it = params_.begin();
    if (it != params_.end()) {
        while (true) {
            urlencode_sv(query, it->first); // name
            query.push_back('=');
            urlencode_sv(query, it->second); // value
            if (++it == params_.end())
                break;
            query.push_back('&');
        }
    }
}
 
inline std::string url_search_params::to_string() const {
    std::string query;
    serialize(query);
    return query;
}
 
UPA_EXPORT_BEGIN
 
// Non-member functions

inline std::ostream& operator<<(std::ostream& os, const url_search_params& usp) {
    return os << usp.to_string();
}

inline void swap(url_search_params& lhs, url_search_params& rhs) noexcept {
    lhs.swap(rhs);
}
 
UPA_EXPORT_END
 
} // namespace upa
 
#endif // UPA_URL_SEARCH_PARAMS_H