qurlquery.cpp

Go to the documentation of this file.

// Copyright (C) 2021 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qurlquery.h"
#include "qurl_p.h"
 
#include <QtCore/qhashfunctions.h>
#include <QtCore/qstringlist.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
typedef QList<std::pair<QString, QString> > Map;
 
class QUrlQueryPrivate : public QSharedData
{
public:
    QUrlQueryPrivate(const QString &query = QString())
        : valueDelimiter(QUrlQuery::defaultQueryValueDelimiter()),
          pairDelimiter(QUrlQuery::defaultQueryPairDelimiter())
    { if (!query.isEmpty()) setQuery(query); }
 
    QString recodeFromUser(const QString &input) const;
    QString recodeToUser(const QString &input, QUrl::ComponentFormattingOptions encoding) const;
 
    void setQuery(const QString &query);
 
    void addQueryItem(const QString &key, const QString &value)
    { itemList.append(std::make_pair(recodeFromUser(key), recodeFromUser(value))); }
    int findRecodedKey(const QString &key, int from = 0) const
    {
        for (int i = from; i < itemList.size(); ++i)
            if (itemList.at(i).first == key)
                return i;
        return itemList.size();
    }
    Map::const_iterator findKey(const QString &key) const
    { return itemList.constBegin() + findRecodedKey(recodeFromUser(key)); }
    Map::iterator findKey(const QString &key)
    { return itemList.begin() + findRecodedKey(recodeFromUser(key)); }
 
    Map itemList;
    QChar valueDelimiter;
    QChar pairDelimiter;
};
 
template<> void QSharedDataPointer<QUrlQueryPrivate>::detach()
{
    if (d && d->ref.loadRelaxed() == 1)
        return;
    QUrlQueryPrivate *x = (d ? new QUrlQueryPrivate(*d)
                             : new QUrlQueryPrivate);
    x->ref.ref();
    if (d && !d->ref.deref())
        delete d;
    d = x;
}
 
// Here's how we do the encoding in QUrlQuery
// The RFC says these are the delimiters:
//    gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
//    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
//                  / "*" / "+" / "," / ";" / "="
// And the definition of query is:
//    query         = *( pchar / "/" / "?" )
//    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
//
// The strict definition of query says that it can have unencoded any
// unreserved, sub-delim, ":", "@", "/" and "?". Or, by exclusion, excluded
// delimiters are "#", "[" and "]" -- if those are present, they must be
// percent-encoded. The fact that "[" and "]" should be encoded is probably a
// mistake in the spec, so we ignore it and leave the decoded.
//
// The internal storage in the Map is equivalent to PrettyDecoded. That means
// the getter methods, when called with the default encoding value, will not
// have to recode anything (except for toString()).
//
// QUrlQuery handling of delimiters is quite simple: we never touch any of
// them, except for the "#" character and the pair and value delimiters. Those
// are always kept in their decoded forms.
//
// But when recreating the query string, in toString(), we must take care of
// the special delimiters: the pair and value delimiters, as well as the "#"
// character if unambiguous decoding is requested.
 
#define decode(x) ushort(x)
#define leave(x)  ushort(0x100 | (x))
#define encode(x) ushort(0x200 | (x))
 
inline QString QUrlQueryPrivate::recodeFromUser(const QString &input) const
{
    // note: duplicated in setQuery()
    QString output;
    ushort prettyDecodedActions[] = {
        decode(pairDelimiter.unicode()),
        decode(valueDelimiter.unicode()),
        decode('#'),
        0
    };
    if (qt_urlRecode(output, input,
                     QUrl::DecodeReserved,
                     prettyDecodedActions))
        return output;
    return input;
}
 
inline bool idempotentRecodeToUser(QUrl::ComponentFormattingOptions encoding)
{
    return encoding == QUrl::PrettyDecoded;
}
 
inline QString QUrlQueryPrivate::recodeToUser(const QString &input, QUrl::ComponentFormattingOptions encoding) const
{
    // our internal formats are stored in "PrettyDecoded" form
    // and there are no ambiguous characters
    if (idempotentRecodeToUser(encoding))
        return input;
 
    if (!(encoding & QUrl::EncodeDelimiters)) {
        QString output;
        if (qt_urlRecode(output, input,
                         encoding, nullptr))
            return output;
        return input;
    }
 
    // re-encode the "#" character and the query delimiter pair
    ushort actions[] = { encode(pairDelimiter.unicode()), encode(valueDelimiter.unicode()),
                         encode('#'), 0 };
    QString output;
    if (qt_urlRecode(output, input, encoding, actions))
        return output;
    return input;
}
 
void QUrlQueryPrivate::setQuery(const QString &query)
{
    ushort prettyDecodedActions[] = {
        decode(pairDelimiter.unicode()),
        decode(valueDelimiter.unicode()),
        decode('#'),
        0
    };
 
    itemList.clear();
    const QChar *pos = query.constData();
    const QChar *const end = pos + query.size();
    while (pos != end) {
        const QChar *begin = pos;
        const QChar *delimiter = nullptr;
        while (pos != end) {
            // scan for the component parts of this pair
            if (!delimiter && *pos == valueDelimiter)
                delimiter = pos;
            if (*pos == pairDelimiter)
                break;
            ++pos;
        }
        if (!delimiter)
            delimiter = pos;
 
        // pos is the end of this pair (the end of the string or the pair delimiter)
        // delimiter points to the value delimiter or to the end of this pair
 
        QString key;
        if (!qt_urlRecode(key, QStringView{begin, delimiter},
                          QUrl::DecodeReserved,
                          prettyDecodedActions))
            key = QString(begin, delimiter - begin);
 
        if (delimiter == pos) {
            // the value delimiter wasn't found, store a null value
            itemList.append(std::make_pair(key, QString()));
        } else if (delimiter + 1 == pos) {
            // if the delimiter was found but the value is empty, store empty-but-not-null
            itemList.append(std::make_pair(key, QString(0, Qt::Uninitialized)));
        } else {
            QString value;
            if (!qt_urlRecode(value, QStringView{delimiter + 1, pos},
                              QUrl::DecodeReserved,
                              prettyDecodedActions))
                value = QString(delimiter + 1, pos - delimiter - 1);
            itemList.append(std::make_pair(key, value));
        }
 
        if (pos != end)
            ++pos;
    }
}
 
// allow QUrlQueryPrivate to detach from null
template <> inline QUrlQueryPrivate *
QSharedDataPointer<QUrlQueryPrivate>::clone()
{
    return d ? new QUrlQueryPrivate(*d) : new QUrlQueryPrivate;
}
 
QUrlQuery::QUrlQuery()
    : d(nullptr)
{
}
 
QUrlQuery::QUrlQuery(const QString &queryString)
    : d(queryString.isEmpty() ? nullptr : new QUrlQueryPrivate(queryString))
{
}
 
QUrlQuery::QUrlQuery(const QUrl &url)
    : d(nullptr)
{
    // use internals to avoid unnecessary recoding
    // ### FIXME: actually do it
    if (url.hasQuery())
        d = new QUrlQueryPrivate(url.query());
}
 
QUrlQuery::QUrlQuery(const QUrlQuery &other)
    : d(other.d)
{
}
 
QUrlQuery::QUrlQuery(QUrlQuery &&other) noexcept
    : d(std::move(other.d))
{
}
 
QUrlQuery &QUrlQuery::operator =(const QUrlQuery &other)
{
    d = other.d;
    return *this;
}
 
QUrlQuery::~QUrlQuery()
{
    // d auto-deletes
}
 
bool comparesEqual(const QUrlQuery &lhs, const QUrlQuery &rhs)
{
    if (lhs.d == rhs.d)
        return true;
    if (lhs.d && rhs.d)
        // keep in sync with qHash(QUrlQuery):
        return lhs.d->valueDelimiter == rhs.d->valueDelimiter &&
                lhs.d->pairDelimiter == rhs.d->pairDelimiter &&
                lhs.d->itemList == rhs.d->itemList;
 
    const QUrlQueryPrivate *x = lhs.d ? lhs.d.data() : rhs.d.data();
    return x->valueDelimiter == QUrlQuery::defaultQueryValueDelimiter() &&
            x->pairDelimiter == QUrlQuery::defaultQueryPairDelimiter() &&
            x->itemList.isEmpty();
}
 
size_t qHash(const QUrlQuery &key, size_t seed) noexcept
{
    if (const QUrlQueryPrivate *d = key.d) {
        QtPrivate::QHashCombine hash;
        // keep in sync with operator==:
        seed = hash(seed, d->valueDelimiter);
        seed = hash(seed, d->pairDelimiter);
        seed = hash(seed, d->itemList);
    }
    return seed;
}
 
bool QUrlQuery::isEmpty() const
{
    return d ? d->itemList.isEmpty() : true;
}
 
bool QUrlQuery::isDetached() const
{
    return d && d->ref.loadRelaxed() == 1;
}
 
void QUrlQuery::clear()
{
    if (d.constData())
        d->itemList.clear();
}
 
void QUrlQuery::setQuery(const QString &queryString)
{
    d->setQuery(queryString);
}
 
static void recodeAndAppend(QString &to, const QString &input,
                            QUrl::ComponentFormattingOptions encoding, const ushort *tableModifications)
{
    if (!qt_urlRecode(to, input, encoding, tableModifications))
        to += input;
}
 
QString QUrlQuery::query(QUrl::ComponentFormattingOptions encoding) const
{
    if (!d)
        return QString();
 
    // unlike the component encoding, for the whole query we need to modify a little:
    //  - the "#" character is unambiguous, so we encode it in EncodeDelimiters mode
    //  - the query delimiter pair must always be encoded
 
    // start with what's always encoded
    ushort tableActions[] = {
        encode(d->pairDelimiter.unicode()),  // 0
        encode(d->valueDelimiter.unicode()), // 1
        0,                                   // 2
        0
    };
    if (encoding & QUrl::EncodeDelimiters) {
        tableActions[2] = encode('#');
    }
 
    QString result;
    Map::const_iterator it = d->itemList.constBegin();
    Map::const_iterator end = d->itemList.constEnd();
 
    {
        int size = 0;
        for ( ; it != end; ++it)
            size += it->first.size() + 1 + it->second.size() + 1;
        result.reserve(size + size / 4);
    }
 
    for (it = d->itemList.constBegin(); it != end; ++it) {
        if (!result.isEmpty())
            result += QChar(d->pairDelimiter);
        recodeAndAppend(result, it->first, encoding, tableActions);
        if (!it->second.isNull()) {
            result += QChar(d->valueDelimiter);
            recodeAndAppend(result, it->second, encoding, tableActions);
        }
    }
    return result;
}
 
void QUrlQuery::setQueryDelimiters(QChar valueDelimiter, QChar pairDelimiter)
{
    d->valueDelimiter = valueDelimiter;
    d->pairDelimiter = pairDelimiter;
}
 
QChar QUrlQuery::queryValueDelimiter() const
{
    return d ? d->valueDelimiter : defaultQueryValueDelimiter();
}
 
QChar QUrlQuery::queryPairDelimiter() const
{
    return d ? d->pairDelimiter : defaultQueryPairDelimiter();
}
 
void QUrlQuery::setQueryItems(const QList<std::pair<QString, QString> > &query)
{
    clear();
    if (query.isEmpty())
        return;
 
    QUrlQueryPrivate *dd = d;
    QList<std::pair<QString, QString> >::const_iterator it = query.constBegin(),
            end = query.constEnd();
    for ( ; it != end; ++it)
        dd->addQueryItem(it->first, it->second);
}
 
QList<std::pair<QString, QString> > QUrlQuery::queryItems(QUrl::ComponentFormattingOptions encoding) const
{
    if (!d)
        return QList<std::pair<QString, QString> >();
    if (idempotentRecodeToUser(encoding))
        return d->itemList;
 
    QList<std::pair<QString, QString> > result;
    Map::const_iterator it = d->itemList.constBegin();
    Map::const_iterator end = d->itemList.constEnd();
    result.reserve(d->itemList.size());
    for ( ; it != end; ++it)
        result << std::make_pair(d->recodeToUser(it->first, encoding),
                                 d->recodeToUser(it->second, encoding));
    return result;
}
 
bool QUrlQuery::hasQueryItem(const QString &key) const
{
    if (!d)
        return false;
    return d->findKey(key) != d->itemList.constEnd();
}
 
void QUrlQuery::addQueryItem(const QString &key, const QString &value)
{
    d->addQueryItem(key, value);
}
 
QString QUrlQuery::queryItemValue(const QString &key, QUrl::ComponentFormattingOptions encoding) const
{
    QString result;
    if (d) {
        Map::const_iterator it = d->findKey(key);
        if (it != d->itemList.constEnd())
            result = d->recodeToUser(it->second, encoding);
    }
    return result;
}
 
QStringList QUrlQuery::allQueryItemValues(const QString &key, QUrl::ComponentFormattingOptions encoding) const
{
    QStringList result;
    if (d) {
        QString encodedKey = d->recodeFromUser(key);
        int idx = d->findRecodedKey(encodedKey);
        while (idx < d->itemList.size()) {
            result << d->recodeToUser(d->itemList.at(idx).second, encoding);
            idx = d->findRecodedKey(encodedKey, idx + 1);
        }
    }
    return result;
}
 
void QUrlQuery::removeQueryItem(const QString &key)
{
    if (d.constData()) {
        auto *p = d.data();
        Map::iterator it = p->findKey(key);
        if (it != p->itemList.end())
            p->itemList.erase(it);
    }
}
 
void QUrlQuery::removeAllQueryItems(const QString &key)
{
    if (d.constData()) {
        auto *p = d.data();
        const QString encodedKey = p->recodeFromUser(key);
        auto firstEqualsEncodedKey = [&encodedKey](const std::pair<QString, QString> &item) {
            return item.first == encodedKey;
        };
        p->itemList.removeIf(firstEqualsEncodedKey);
    }
}
 
QT_END_NAMESPACE
 
#undef decode
#undef leave
#undef encode