QUrlPrivate Class Reference

Public Types
enum	ParseOptions { ParseAndSet, ParseOnly }
enum	State { Parsed = 0x1, Validated = 0x2, Normalized = 0x4, HostCanonicalized = 0x8 }

Public Functions
QString	authority (QUrl::FormattingOptions options=QUrl::None) const
QString	canonicalHost () const
void	clear ()
QString	createErrorString ()
void	ensureEncodedParts () const
QString	fragmentImpl () const
QByteArray	mergePaths (const QByteArray &relativePath) const
const QByteArray &	normalized () const
void	parse (ParseOptions parseOptions=ParseAndSet) const
void	queryItem (int pos, int *value, int *end)
	QUrlPrivate ()
	QUrlPrivate (const QUrlPrivate &other)
void	setAuthority (const QString &auth)
void	setEncodedAuthority (const QByteArray &authority)
void	setEncodedUrl (const QByteArray &encodedUrl, QUrl::ParsingMode parsingMode)
void	setEncodedUserInfo (const QUrlParseData *parseData)
bool	setUrl (const QString &url)
void	setUserInfo (const QString &userInfo)
QByteArray	toEncoded (QUrl::FormattingOptions options=QUrl::None) const
QString	userInfo (QUrl::FormattingOptions options=QUrl::None) const
void	validate () const

Public Variables
QByteArray	encodedFragment
QByteArray	encodedNormalized
QByteArray	encodedOriginal
QByteArray	encodedPassword
QByteArray	encodedPath
QByteArray	encodedUserName
QUrlErrorInfo	errorInfo
QString	fragment
bool	hasFragment
bool	hasQuery
QString	host
bool	isHostValid
bool	isValid
QMutex	mutex
char	pairDelimiter
QUrl::ParsingMode	parsingMode
QString	password
QString	path
int	port
QByteArray	query
QAtomicInt	ref
QString	scheme
int	stateFlags
QString	userName
char	valueDelimiter

Detailed Description

Definition at line 320 of file qurl.cpp.

Enumerations

ParseOptions

enum QUrlPrivate::ParseOptions

Enumerator
ParseAndSet
ParseOnly

Definition at line 343 of file qurl.cpp.

                      {
        ParseAndSet,
        ParseOnly
    };

State

enum QUrlPrivate::State

Enumerator
Parsed
Validated
Normalized
HostCanonicalized

Definition at line 381 of file qurl.cpp.

               {
        Parsed = 0x1,
        Validated = 0x2,
        Normalized = 0x4,
        HostCanonicalized = 0x8
    };

Constructors and Destructors

QUrlPrivate() [1/2]

QUrlPrivate::QUrlPrivate

(

)

Definition at line 3439 of file qurl.cpp.

{
    ref = 1;
    port = -1;
    isValid = false;
    isHostValid = true;
    parsingMode = QUrl::TolerantMode;
    valueDelimiter = '=';
    pairDelimiter = '&';
    stateFlags = 0;
    hasFragment = false;
    hasQuery = false;
}

QUrlPrivate() [2/2]

QUrlPrivate::QUrlPrivate

(

const QUrlPrivate &

other

)

Definition at line 3454 of file qurl.cpp.

    : scheme(copy.scheme),
      userName(copy.userName),
      password(copy.password),
      host(copy.host),
      path(copy.path),
      query(copy.query),
      fragment(copy.fragment),
      encodedOriginal(copy.encodedOriginal),
      encodedUserName(copy.encodedUserName),
      encodedPassword(copy.encodedPassword),
      encodedPath(copy.encodedPath),
      encodedFragment(copy.encodedFragment),
      port(copy.port),
      parsingMode(copy.parsingMode),
      hasQuery(copy.hasQuery),
      hasFragment(copy.hasFragment),
      isValid(copy.isValid),
      isHostValid(copy.isHostValid),
      valueDelimiter(copy.valueDelimiter),
      pairDelimiter(copy.pairDelimiter),
      stateFlags(copy.stateFlags),
      encodedNormalized(copy.encodedNormalized)
{ ref = 1; }

Functions

authority()

QString QUrlPrivate::authority

(

QUrl::FormattingOptions

options = QUrl::None

)

const

Definition at line 3568 of file qurl.cpp.

Referenced by QUrl::authority(), mergePaths(), QUrl::resolved(), toEncoded(), QUrl::toString(), and validate().

{
    // Caller must lock mutex first

    if ((options & QUrl::RemoveAuthority) == QUrl::RemoveAuthority)
        return QString();

    QString tmp = userInfo(options);
    if (!tmp.isEmpty())
        tmp += QLatin1Char('@');
    tmp += canonicalHost();
    if (!(options & QUrl::RemovePort) && port != -1)
        tmp += QLatin1Char(':') + QString::number(port);

    return tmp;
}

canonicalHost()

QString QUrlPrivate::canonicalHost

(

)

const

Definition at line 3479 of file qurl.cpp.

Referenced by authority(), QUrl::host(), and normalized().

{
    // Caller must lock mutex first
    if (QURL_HASFLAG(stateFlags, HostCanonicalized) || host.isEmpty())
        return host;

    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
    QURL_SETFLAG(that->stateFlags, HostCanonicalized);
    if (host.contains(QLatin1Char(':'))) {
        // This is an IP Literal, use _IPLiteral to validate
        QByteArray ba = host.toLatin1();
        bool needsBraces = false;
        if (!ba.startsWith('[')) {
            // surround the IP Literal with [ ] if it's not already done so
            ba.reserve(ba.length() + 2);
            ba.prepend('[');
            ba.append(']');
            needsBraces = true;
        }

        const char *ptr = ba.constData();
        if (!_IPLiteral(&ptr))
            that->host.clear();
        else if (needsBraces)
            that->host = QString::fromLatin1(ba.toLower());
        else
            that->host = host.toLower();
    } else {
        that->host = qt_ACE_do(host, NormalizeAce);
    }
    that->isHostValid = !that->host.isNull();
    return that->host;
}

clear()

void QUrlPrivate::clear

(

)

Definition at line 3968 of file qurl.cpp.

Referenced by QUrl::setEncodedUrl(), and QUrl::setUrl().

{
    scheme.clear();
    userName.clear();
    password.clear();
    host.clear();
    port = -1;
    path.clear();
    query.clear();
    fragment.clear();

    encodedOriginal.clear();
    encodedUserName.clear();
    encodedPassword.clear();
    encodedPath.clear();
    encodedFragment.clear();
    encodedNormalized.clear();

    isValid = false;
    hasQuery = false;
    hasFragment = false;

    valueDelimiter = '=';
    pairDelimiter = '&';

    QURL_UNSETFLAG(stateFlags, Parsed | Validated | Normalized | HostCanonicalized);
}

createErrorString()

QString QUrlPrivate::createErrorString

(

)

Definition at line 4164 of file qurl.cpp.

Referenced by QUrl::errorString().

{
    if (isValid && isHostValid)
        return QString();

    QString errorString(QLatin1String(QT_TRANSLATE_NOOP(QUrl, "Invalid URL \"")));
    errorString += QLatin1String(encodedOriginal.constData());
    errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "\""));

    if (errorInfo._source) {
        int position = encodedOriginal.indexOf(errorInfo._source) - 1;
        if (position > 0) {
            errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": error at position "));
            errorString += QString::number(position);
        } else {
            errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": "));
            errorString += QLatin1String(errorInfo._source);
        }
    }

    if (errorInfo._expected) {
        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": expected \'"));
        errorString += QLatin1Char(errorInfo._expected);
        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "\'"));
    } else {
        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": "));
        if (isHostValid)
            errorString += QLatin1String(errorInfo._message);
        else
            errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "invalid hostname"));
    }
    if (errorInfo._found) {
        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ", but found \'"));
        errorString += QLatin1Char(errorInfo._found);
        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "\'"));
    }
    return errorString;
}

ensureEncodedParts()

void QUrlPrivate::ensureEncodedParts

(

)

const

Definition at line 3550 of file qurl.cpp.

Referenced by QUrl::encodedFragment(), QUrl::encodedPassword(), QUrl::encodedPath(), QUrl::encodedUserName(), mergePaths(), normalized(), QUrl::resolved(), and toEncoded().

{
    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);

    if (encodedUserName.isNull())
        // userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
        that->encodedUserName = toPercentEncodingHelper(userName, userNameExcludeChars);
    if (encodedPassword.isNull())
        // userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
        that->encodedPassword = toPercentEncodingHelper(password, passwordExcludeChars);
    if (encodedPath.isNull())
        // pchar = unreserved / pct-encoded / sub-delims / ":" / "@" ... also "/"
        that->encodedPath = toPercentEncodingHelper(path, pathExcludeChars);
    if (encodedFragment.isNull())
        // fragment      = *( pchar / "/" / "?" )
        that->encodedFragment = toPercentEncodingHelper(fragment, fragmentExcludeChars);
}

fragmentImpl()

QString QUrlPrivate::fragmentImpl

(

)

const

Definition at line 5696 of file qurl.cpp.

Referenced by QUrl::fragment(), QUrl::resolved(), and QUrl::toString().

{
    if (fragment.isNull() && !encodedFragment.isNull()) {
        QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
        that->fragment = fromPercentEncodingHelper(encodedFragment);
    }
    return fragment;
}

mergePaths()

QByteArray QUrlPrivate::mergePaths

(

const QByteArray &

relativePath

)

const

Definition at line 3700 of file qurl.cpp.

Referenced by QUrl::resolved().

{
    // Caller must lock mutex first

    if (encodedPath.isNull())
        ensureEncodedParts();

    // If the base URI has a defined authority component and an empty
    // path, then return a string consisting of "/" concatenated with
    // the reference's path; otherwise,
    if (!authority().isEmpty() && encodedPath.isEmpty())
        return '/' + relativePath;

    // Return a string consisting of the reference's path component
    // appended to all but the last segment of the base URI's path
    // (i.e., excluding any characters after the right-most "/" in the
    // base URI path, or excluding the entire base URI path if it does
    // not contain any "/" characters).
    QByteArray newPath;
    if (!encodedPath.contains('/'))
        newPath = relativePath;
    else
        newPath = encodedPath.left(encodedPath.lastIndexOf('/') + 1) + relativePath;

    return newPath;
}

normalized()

const QByteArray & QUrlPrivate::normalized

(

)

const

Definition at line 4082 of file qurl.cpp.

Referenced by QUrl::operator<(), QUrl::operator==(), and toEncoded().

{
    // Caller must lock mutex first
    if (QURL_HASFLAG(stateFlags, QUrlPrivate::Normalized))
        return encodedNormalized;

    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
    QURL_SETFLAG(that->stateFlags, QUrlPrivate::Normalized);

    QUrlPrivate tmp = *this;
    tmp.scheme = tmp.scheme.toLower();
    tmp.host = tmp.canonicalHost();

    // ensure the encoded and normalized parts of the URL
    tmp.ensureEncodedParts();
    if (tmp.encodedUserName.contains('%'))
        q_normalizePercentEncoding(&tmp.encodedUserName, userNameExcludeChars);
    if (tmp.encodedPassword.contains('%'))
        q_normalizePercentEncoding(&tmp.encodedPassword, passwordExcludeChars);
    if (tmp.encodedFragment.contains('%'))
        q_normalizePercentEncoding(&tmp.encodedFragment, fragmentExcludeChars);

    if (tmp.encodedPath.contains('%')) {
        // the path is a bit special:
        // the slashes shouldn't be encoded or decoded.
        // They should remain exactly like they are right now
        //
        // treat the path as a slash-separated sequence of pchar
        QByteArray result;
        result.reserve(tmp.encodedPath.length());
        if (tmp.encodedPath.startsWith('/'))
            result.append('/');

        const char *data = tmp.encodedPath.constData();
        int lastSlash = 0;
        int nextSlash;
        do {
            ++lastSlash;
            nextSlash = tmp.encodedPath.indexOf('/', lastSlash);
            int len;
            if (nextSlash == -1)
                len = tmp.encodedPath.length() - lastSlash;
            else
                len = nextSlash - lastSlash;

            if (memchr(data + lastSlash, '%', len)) {
                // there's at least one percent before the next slash
                QByteArray block = QByteArray(data + lastSlash, len);
                q_normalizePercentEncoding(&block, pathExcludeChars);
                result.append(block);
            } else {
                // no percents in this path segment, append wholesale
                result.append(data + lastSlash, len);
            }

            // append the slash too, if it's there
            if (nextSlash != -1)
                result.append('/');

            lastSlash = nextSlash;
        } while (lastSlash != -1);

        tmp.encodedPath = result;
    }

    if (!tmp.scheme.isEmpty()) // relative test
        removeDotsFromPath(&tmp.encodedPath);

    int qLen = tmp.query.length();
    for (int i = 0; i < qLen; i++) {
        if (qLen - i > 2 && tmp.query.at(i) == '%') {
            ++i;
            tmp.query[i] = qToLower(tmp.query.at(i));
            ++i;
            tmp.query[i] = qToLower(tmp.query.at(i));
        }
    }
    encodedNormalized = tmp.toEncoded();

    return encodedNormalized;
}

parse()

void QUrlPrivate::parse

(

ParseOptions

parseOptions = ParseAndSet

)

const

Definition at line 3852 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), QUrl::allEncodedQueryItemValues(), QUrl::allQueryItemValues(), QUrl::authority(), QUrl::encodedFragment(), QUrl::encodedPassword(), QUrl::encodedPath(), QUrl::encodedQuery(), QUrl::encodedQueryItems(), QUrl::encodedQueryItemValue(), QUrl::encodedUserName(), QUrl::fragment(), QUrl::hasEncodedQueryItem(), QUrl::hasFragment(), QUrl::hasQuery(), QUrl::host(), QUrl::isLocalFile(), QUrl::isParentOf(), QUrl::isRelative(), QUrl::isValid(), QUrl::operator<(), QUrl::operator==(), QUrl::password(), QUrl::path(), QUrl::port(), QUrl::queryItems(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), QUrl::resolved(), QUrl::scheme(), QUrl::setAuthority(), QUrl::setEncodedFragment(), QUrl::setEncodedPassword(), QUrl::setEncodedPath(), QUrl::setEncodedQuery(), QUrl::setEncodedQueryItems(), QUrl::setEncodedUserName(), QUrl::setFragment(), QUrl::setHost(), QUrl::setPassword(), QUrl::setPath(), QUrl::setPort(), QUrl::setQueryItems(), QUrl::setScheme(), QUrl::setUserInfo(), QUrl::setUserName(), toEncoded(), QUrl::toString(), QUrl::userInfo(), QUrl::userName(), and validate().

{
    // Caller must lock mutex first
    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
    that->errorInfo.setParams(0, 0, 0, 0);
    if (encodedOriginal.isEmpty()) {
        that->isValid = false;
        that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "empty"),
                                  0, 0);
        QURL_SETFLAG(that->stateFlags, Validated | Parsed);
        return;
    }


    QUrlParseData parseData;
    memset(&parseData, 0, sizeof(parseData));
    parseData.userInfoDelimIndex = -1;
    parseData.port = -1;

    const char *pptr = (char *) encodedOriginal.constData();
    const char **ptr = &pptr;

#if defined (QURL_DEBUG)
    qDebug("QUrlPrivate::parse(), parsing \"%s\"", pptr);
#endif

    // optional scheme
    bool isSchemeValid = _scheme(ptr, &parseData);

    if (isSchemeValid == false) {
        that->isValid = false;
        char ch = *((*ptr)++);
        that->errorInfo.setParams(*ptr, QT_TRANSLATE_NOOP(QUrl, "unexpected URL scheme"),
                                  0, ch);
        QURL_SETFLAG(that->stateFlags, Validated | Parsed);
#if defined (QURL_DEBUG)
        qDebug("QUrlPrivate::parse(), unrecognized: %c%s", ch, *ptr);
#endif
        return;
    }

    // hierpart
    _hierPart(ptr, &parseData);

    // optional query
    char ch = *((*ptr)++);
    if (ch == '?') {
        that->hasQuery = true;
        _query(ptr, &parseData);
        ch = *((*ptr)++);
    }

    // optional fragment
    if (ch == '#') {
        that->hasFragment = true;
        _fragment(ptr, &parseData);
    } else if (ch != '\0') {
        that->isValid = false;
        that->errorInfo.setParams(*ptr, QT_TRANSLATE_NOOP(QUrl, "expected end of URL"),
                                  0, ch);
        QURL_SETFLAG(that->stateFlags, Validated | Parsed);
#if defined (QURL_DEBUG)
        qDebug("QUrlPrivate::parse(), unrecognized: %c%s", ch, *ptr);
#endif
        return;
    }

    // when doing lazy validation, this function is called after
    // encodedOriginal has been constructed from the individual parts,
    // only to see if the constructed URL can be parsed. in that case,
    // parse() is called in ParseOnly mode; we don't want to set all
    // the members over again.
    if (parseOptions == ParseAndSet) {
        QURL_UNSETFLAG(that->stateFlags, HostCanonicalized);

        if (parseData.scheme) {
            QByteArray s(parseData.scheme, parseData.schemeLength);
            that->scheme = fromPercentEncodingMutable(&s);
        }

        that->setEncodedUserInfo(&parseData);

        QByteArray h(parseData.host, parseData.hostLength);
        that->host = fromPercentEncodingMutable(&h);
        that->port = uint(parseData.port) <= 0xffffU ? parseData.port : -1;

        that->path.clear();
        that->encodedPath = QByteArray(parseData.path, parseData.pathLength);

        if (that->hasQuery)
            that->query = QByteArray(parseData.query, parseData.queryLength);
        else
            that->query.clear();

        that->fragment.clear();
        if (that->hasFragment) {
            that->encodedFragment = QByteArray(parseData.fragment, parseData.fragmentLength);
        } else {
            that->encodedFragment.clear();
        }
    }

    that->isValid = true;
    QURL_SETFLAG(that->stateFlags, Parsed);

#if defined (QURL_DEBUG)
    qDebug("QUrl::setUrl(), scheme = %s", that->scheme.toLatin1().constData());
    qDebug("QUrl::setUrl(), userInfo = %s", that->userInfo.toLatin1().constData());
    qDebug("QUrl::setUrl(), host = %s", that->host.toLatin1().constData());
    qDebug("QUrl::setUrl(), port = %i", that->port);
    qDebug("QUrl::setUrl(), path = %s", fromPercentEncodingHelper(__path).toLatin1().constData());
    qDebug("QUrl::setUrl(), query = %s", __query.constData());
    qDebug("QUrl::setUrl(), fragment = %s", fromPercentEncodingHelper(__fragment).toLatin1().constData());
#endif
}

queryItem()

void QUrlPrivate::queryItem	(	int	pos,
		int *	value,
		int *	end
	)

Definition at line 3727 of file qurl.cpp.

Referenced by QUrl::allEncodedQueryItemValues(), QUrl::allQueryItemValues(), QUrl::encodedQueryItems(), QUrl::encodedQueryItemValue(), QUrl::hasEncodedQueryItem(), QUrl::queryItems(), QUrl::removeAllEncodedQueryItems(), and QUrl::removeEncodedQueryItem().

{
    *end = query.indexOf(pairDelimiter, pos);
    if (*end == -1)
        *end = query.size();
    *value = pos;
    while (*value < *end) {
        if (query[*value] == valueDelimiter)
            break;
        ++*value;
    }
}

setAuthority()

void QUrlPrivate::setAuthority

(

const QString &

auth

)

Definition at line 3585 of file qurl.cpp.

Referenced by QUrl::setAuthority().

{
    isHostValid = true;
    if (auth.isEmpty()) {
        setUserInfo(QString());
        if (auth.isNull())
            host.clear();
        else
            host = QLatin1String("");
        port = -1;
        return;
    }

    // find the port section of the authority by searching from the
    // end towards the beginning for numbers until a ':' is reached.
    int portIndex = auth.length() - 1;
    if (portIndex == 0) {
        portIndex = -1;
    } else {
        short c = auth.at(portIndex--).unicode();
        if (c < '0' || c > '9') {
            portIndex = -1;
        } else while (portIndex >= 0) {
            c = auth.at(portIndex).unicode();
            if (c == ':') {
                break;
            } else if (c == '.') {
                portIndex = -1;
                break;
            }
            --portIndex;
        }
    }

    if (portIndex != -1) {
        port = 0;
        for (int i = portIndex + 1; i < auth.length(); ++i)
            port = (port * 10) + (auth.at(i).unicode() - '0');
    } else {
        port = -1;
    }

    int userInfoIndex = auth.indexOf(QLatin1Char('@'));
    if (userInfoIndex != -1 && (portIndex == -1 || userInfoIndex < portIndex))
        setUserInfo(auth.left(userInfoIndex));

    int hostIndex = 0;
    if (userInfoIndex != -1)
        hostIndex = userInfoIndex + 1;
    int hostLength = auth.length() - hostIndex;
    if (portIndex != -1)
        hostLength -= (auth.length() - portIndex);

    host = auth.mid(hostIndex, hostLength).trimmed();
}

setEncodedAuthority()

void QUrlPrivate::setEncodedAuthority

(

const QByteArray &

authority

)

setEncodedUrl()

void QUrlPrivate::setEncodedUrl	(	const QByteArray &	encodedUrl,
		QUrl::ParsingMode	parsingMode
	)

Definition at line 4458 of file qurl.cpp.

Referenced by QUrl::setEncodedUrl(), and QUrl::setUrl().

{
    // Caller must lock mutex first
    QByteArray tmp = encodedUrl;
    if ((this->parsingMode = parsingMode) == QUrl::TolerantMode) {
        // Replace stray % with %25
        QByteArray copy = tmp;
        for (int i = 0, j = 0; i < copy.size(); ++i, ++j) {
            if (copy.at(i) == '%') {
                if (i + 2 >= copy.size() || !isHex(copy.at(i + 1)) || !isHex(copy.at(i + 2))) {
                    tmp.replace(j, 1, "%25");
                    j += 2;
                }
            }
        }

        // Find the host part
        int hostStart = tmp.indexOf("//");
        int hostEnd = -1;
        if (hostStart != -1) {
            // Has host part, find delimiter
            hostStart += 2; // skip "//"
            hostEnd = tmp.indexOf('/', hostStart);
            if (hostEnd == -1)
                hostEnd = tmp.indexOf('#', hostStart);
            if (hostEnd == -1)
                hostEnd = tmp.indexOf('?');
            if (hostEnd == -1)
                hostEnd = tmp.length() - 1;
        }

        // Reserved and unreserved characters are fine
//         unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
//         reserved      = gen-delims / sub-delims
//         gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
//         sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
//                         / "*" / "+" / "," / ";" / "="
        // Replace everything else with percent encoding
        static const char doEncode[] = " \"<>[\\]^`{|}";
        static const char doEncodeHost[] = " \"<>\\^`{|}";
        for (int i = 0; i < tmp.size(); ++i) {
            quint8 c = quint8(tmp.at(i));
            if (c < 32 || c > 127 ||
                strchr(hostStart <= i && i <= hostEnd ? doEncodeHost : doEncode, c)) {
                char buf[4];
                buf[0] = '%';
                buf[1] = toHex(c >> 4);
                buf[2] = toHex(c & 0xf);
                buf[3] = '\0';
                tmp.replace(i, 1, buf);
                i += 2;
            }
        }
    }

    encodedOriginal = tmp;
}

setEncodedUserInfo()

void QUrlPrivate::setEncodedUserInfo

(

const QUrlParseData *

parseData

)

Definition at line 3656 of file qurl.cpp.

Referenced by parse().

{
    userName.clear();
    password.clear();
    if (!parseData->userInfoLength) {
        encodedUserName.clear();
        encodedPassword.clear();
    } else if (parseData->userInfoDelimIndex == -1) {
        encodedUserName = QByteArray(parseData->userInfo, parseData->userInfoLength);
        encodedPassword.clear();
    } else {
        encodedUserName = QByteArray(parseData->userInfo, parseData->userInfoDelimIndex);
        encodedPassword = QByteArray(parseData->userInfo + parseData->userInfoDelimIndex + 1,
                                     parseData->userInfoLength - parseData->userInfoDelimIndex - 1);
    }
}

setUrl()

bool QUrlPrivate::setUrl

(

const QString &

url

)

setUserInfo()

void QUrlPrivate::setUserInfo

(

const QString &

userInfo

)

Definition at line 3641 of file qurl.cpp.

Referenced by setAuthority(), and QUrl::setUserInfo().

{
    encodedUserName.clear();
    encodedPassword.clear();

    int delimIndex = userInfo.indexOf(QLatin1Char(':'));
    if (delimIndex == -1) {
        userName = userInfo;
        password.clear();
        return;
    }
    userName = userInfo.left(delimIndex);
    password = userInfo.right(userInfo.length() - delimIndex - 1);
}

toEncoded()

QByteArray QUrlPrivate::toEncoded

(

QUrl::FormattingOptions

options = QUrl::None

)

const

Definition at line 3996 of file qurl.cpp.

Referenced by normalized(), QUrl::resolved(), QUrl::toEncoded(), and validate().

{
    // Caller must lock mutex first
    if (!QURL_HASFLAG(stateFlags, Parsed)) parse();
    else ensureEncodedParts();

    if (options==0x100) // private - see qHash(QUrl)
        return normalized();

    QByteArray url;

    if (!(options & QUrl::RemoveScheme) && !scheme.isEmpty()) {
        url += scheme.toLatin1();
        url += ':';
    }
    QString savedHost = host;  // pre-validation, may be invalid!
    QString auth = authority();
    bool doFileScheme = scheme == QLatin1String("file") && encodedPath.startsWith('/');
    if ((options & QUrl::RemoveAuthority) != QUrl::RemoveAuthority && (!auth.isNull() || doFileScheme || !savedHost.isEmpty())) {
        if (doFileScheme && !encodedPath.startsWith('/'))
            url += '/';
        url += "//";

        if ((options & QUrl::RemoveUserInfo) != QUrl::RemoveUserInfo) {
            bool hasUserOrPass = false;
            if (!userName.isEmpty()) {
                url += encodedUserName;
                hasUserOrPass = true;
            }
            if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
                url += ':';
                url += encodedPassword;
                hasUserOrPass = true;
            }
            if (hasUserOrPass)
                url += '@';
        }

        if (host.startsWith(QLatin1Char('['))) {
            url += host.toLatin1();
        } else if (host.contains(QLatin1Char(':'))) {
            url += '[';
            url += host.toLatin1();
            url += ']';
        } else if (host.isEmpty() && !savedHost.isEmpty()) {
            // this case is only possible with an invalid URL
            // it's here only so that we can keep the original, invalid hostname
            // in encodedOriginal.
            // QUrl::isValid() will return false, so toEncoded() can be anything (it's not valid)
            url += savedHost.toUtf8();
        } else {
            url += QUrl::toAce(host);
        }
        if (!(options & QUrl::RemovePort) && port != -1) {
            url += ':';
            url += QString::number(port).toAscii();
        }
    }

    if (!(options & QUrl::RemovePath)) {
        // check if we need to insert a slash
        if (!encodedPath.isEmpty() && !auth.isEmpty()) {
            if (!encodedPath.startsWith('/'))
                url += '/';
        }
        url += encodedPath;

        // check if we need to remove trailing slashes
        while ((options & QUrl::StripTrailingSlash) && url.endsWith('/'))
            url.chop(1);
    }

    if (!(options & QUrl::RemoveQuery) && hasQuery) {
        url += '?';
        url += query;
    }
    if (!(options & QUrl::RemoveFragment) && hasFragment) {
        url += '#';
        url += encodedFragment;
    }

    return url;
}

userInfo()

QString QUrlPrivate::userInfo

(

QUrl::FormattingOptions

options = QUrl::None

)

const

Definition at line 3673 of file qurl.cpp.

Referenced by authority(), parse(), QUrl::password(), setUserInfo(), QUrl::userInfo(), and QUrl::userName().

{
    if ((options & QUrl::RemoveUserInfo) == QUrl::RemoveUserInfo)
        return QString();

    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
    if (userName.isNull())
        that->userName = fromPercentEncodingHelper(encodedUserName);
    if (password.isNull())
        that->password = fromPercentEncodingHelper(encodedPassword);

    QString tmp = userName;

    if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
        tmp += QLatin1Char(':');
        tmp += password;
    }

    return tmp;
}

validate()

void QUrlPrivate::validate

(

)

const

Definition at line 3818 of file qurl.cpp.

Referenced by QUrl::isValid(), and QUrl::port().

{
    // Caller must lock mutex first
    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
    that->encodedOriginal = that->toEncoded(); // may detach
    parse(ParseOnly);

    QURL_SETFLAG(that->stateFlags, Validated);

    if (!isValid)
        return;

    QString auth = authority(); // causes the non-encoded forms to be valid

    // authority() calls canonicalHost() which sets this
    if (!isHostValid)
        return;

    if (scheme == QLatin1String("mailto")) {
        if (!host.isEmpty() || port != -1 || !userName.isEmpty() || !password.isEmpty()) {
            that->isValid = false;
            that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "expected empty host, username,"
                                                           "port and password"),
                                      0, 0);
        }
    } else if (scheme == QLatin1String("ftp") || scheme == QLatin1String("http")) {
        if (host.isEmpty() && !(path.isEmpty() && encodedPath.isEmpty())) {
            that->isValid = false;
            that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "the host is empty, but not the path"),
                                      0, 0);
        }
    }
}

Properties

encodedFragment

QByteArray QUrlPrivate::encodedFragment

Definition at line 368 of file qurl.cpp.

Referenced by clear(), QUrl::encodedFragment(), ensureEncodedParts(), QUrl::isEmpty(), normalized(), parse(), QUrl::setEncodedFragment(), QUrl::setFragment(), and toEncoded().

encodedNormalized

QByteArray QUrlPrivate::encodedNormalized

mutable

Definition at line 396 of file qurl.cpp.

Referenced by clear(), and normalized().

encodedOriginal

QByteArray QUrlPrivate::encodedOriginal

Definition at line 364 of file qurl.cpp.

Referenced by clear(), createErrorString(), QUrl::isEmpty(), parse(), and validate().

encodedPassword

QByteArray QUrlPrivate::encodedPassword

Definition at line 366 of file qurl.cpp.

Referenced by clear(), QUrl::encodedPassword(), ensureEncodedParts(), QUrl::isEmpty(), normalized(), QUrl::resolved(), QUrl::setEncodedPassword(), setEncodedUserInfo(), QUrl::setPassword(), setUserInfo(), toEncoded(), and userInfo().

encodedPath

QByteArray QUrlPrivate::encodedPath

Definition at line 367 of file qurl.cpp.

Referenced by clear(), QUrl::encodedPath(), ensureEncodedParts(), QUrl::isEmpty(), mergePaths(), normalized(), parse(), QUrl::path(), QUrl::resolved(), QUrl::setEncodedPath(), QUrl::setPath(), toEncoded(), and validate().

encodedUserName

QByteArray QUrlPrivate::encodedUserName

Definition at line 365 of file qurl.cpp.

Referenced by clear(), QUrl::encodedUserName(), ensureEncodedParts(), QUrl::isEmpty(), normalized(), QUrl::resolved(), setEncodedUserInfo(), QUrl::setEncodedUserName(), setUserInfo(), QUrl::setUserName(), toEncoded(), and userInfo().

errorInfo

QUrlErrorInfo QUrlPrivate::errorInfo

mutable

Definition at line 399 of file qurl.cpp.

Referenced by createErrorString(), parse(), and validate().

fragment

QString QUrlPrivate::fragment

Definition at line 362 of file qurl.cpp.

Referenced by clear(), ensureEncodedParts(), fragmentImpl(), QUrl::isEmpty(), parse(), QUrl::setEncodedFragment(), and QUrl::setFragment().

hasFragment

bool QUrlPrivate::hasFragment

Definition at line 374 of file qurl.cpp.

Referenced by clear(), QUrl::hasFragment(), parse(), QUrl::setEncodedFragment(), QUrl::setFragment(), toEncoded(), and QUrl::toString().

hasQuery

bool QUrlPrivate::hasQuery

Definition at line 373 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), clear(), QUrl::hasQuery(), parse(), QUrl::resolved(), QUrl::setEncodedQuery(), QUrl::setEncodedQueryItems(), QUrl::setQueryItems(), toEncoded(), and QUrl::toString().

host

QString QUrlPrivate::host

Definition at line 359 of file qurl.cpp.

Referenced by canonicalHost(), clear(), QUrl::isEmpty(), normalized(), parse(), QUrl::resolved(), setAuthority(), QUrl::setHost(), toEncoded(), QUrl::toLocalFile(), and validate().

isHostValid

bool QUrlPrivate::isHostValid

Definition at line 376 of file qurl.cpp.

Referenced by canonicalHost(), createErrorString(), QUrl::isValid(), setAuthority(), QUrl::setHost(), and validate().

isValid

bool QUrlPrivate::isValid

Definition at line 375 of file qurl.cpp.

Referenced by clear(), createErrorString(), QUrl::isValid(), parse(), and validate().

mutex

QMutex QUrlPrivate::mutex

mutable

Definition at line 394 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), QUrl::allEncodedQueryItemValues(), QUrl::allQueryItemValues(), QUrl::authority(), QUrl::detach(), QUrl::encodedFragment(), QUrl::encodedPassword(), QUrl::encodedPath(), QUrl::encodedQuery(), QUrl::encodedQueryItems(), QUrl::encodedQueryItemValue(), QUrl::encodedUserName(), QUrl::errorString(), QUrl::fragment(), QUrl::hasEncodedQueryItem(), QUrl::hasFragment(), QUrl::hasQuery(), QUrl::host(), QUrl::isEmpty(), QUrl::isLocalFile(), QUrl::isParentOf(), QUrl::isRelative(), QUrl::isValid(), QUrl::operator<(), QUrl::operator==(), QUrl::password(), QUrl::path(), QUrl::port(), QUrl::queryItems(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), QUrl::resolved(), QUrl::scheme(), QUrl::setAuthority(), QUrl::setEncodedFragment(), QUrl::setEncodedPassword(), QUrl::setEncodedPath(), QUrl::setEncodedQuery(), QUrl::setEncodedQueryItems(), QUrl::setEncodedUrl(), QUrl::setEncodedUserName(), QUrl::setFragment(), QUrl::setHost(), QUrl::setPassword(), QUrl::setPath(), QUrl::setPort(), QUrl::setQueryDelimiters(), QUrl::setQueryItems(), QUrl::setScheme(), QUrl::setUrl(), QUrl::setUserInfo(), QUrl::setUserName(), QUrl::toEncoded(), QUrl::toLocalFile(), QUrl::toString(), QUrl::userInfo(), and QUrl::userName().

pairDelimiter

char QUrlPrivate::pairDelimiter

Definition at line 379 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), clear(), queryItem(), QUrl::queryPairDelimiter(), QUrl::setEncodedQueryItems(), QUrl::setQueryDelimiters(), and QUrl::setQueryItems().

parsingMode

QUrl::ParsingMode QUrlPrivate::parsingMode

Definition at line 371 of file qurl.cpp.

Referenced by QUrl::QUrl().

password

QString QUrlPrivate::password

Definition at line 358 of file qurl.cpp.

Referenced by clear(), ensureEncodedParts(), QUrl::isEmpty(), QUrl::password(), QUrl::setEncodedPassword(), setEncodedUserInfo(), QUrl::setPassword(), setUserInfo(), toEncoded(), userInfo(), and validate().

path

QString QUrlPrivate::path

Definition at line 360 of file qurl.cpp.

Referenced by clear(), ensureEncodedParts(), QUrl::isEmpty(), parse(), QUrl::path(), QUrl::resolved(), QUrl::setEncodedPath(), QUrl::setPath(), and validate().

port

int QUrlPrivate::port

Definition at line 370 of file qurl.cpp.

Referenced by authority(), clear(), QUrl::isEmpty(), parse(), QUrl::port(), QUrl::resolved(), setAuthority(), QUrl::setPort(), toEncoded(), and validate().

query

QByteArray QUrlPrivate::query

Definition at line 361 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), QUrl::allEncodedQueryItemValues(), QUrl::allQueryItemValues(), clear(), QUrl::encodedQuery(), QUrl::encodedQueryItems(), QUrl::encodedQueryItemValue(), QUrl::hasEncodedQueryItem(), QUrl::isEmpty(), normalized(), parse(), queryItem(), QUrl::queryItems(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), QUrl::resolved(), QUrl::setEncodedQuery(), QUrl::setEncodedQueryItems(), QUrl::setQueryItems(), toEncoded(), and QUrl::toString().

ref

QAtomicInt QUrlPrivate::ref

Definition at line 354 of file qurl.cpp.

Referenced by QUrl::clear(), QUrl::detach(), QUrl::isDetached(), QUrl::operator=(), QUrl::QUrl(), QUrlPrivate(), and QUrl::~QUrl().

scheme

QString QUrlPrivate::scheme

Definition at line 356 of file qurl.cpp.

Referenced by clear(), QUrl::isEmpty(), QUrl::isLocalFile(), QUrl::isRelative(), normalized(), parse(), QUrl::resolved(), QUrl::scheme(), QUrl::setScheme(), toEncoded(), QUrl::toString(), and validate().

stateFlags

int QUrlPrivate::stateFlags

Definition at line 387 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), QUrl::allEncodedQueryItemValues(), QUrl::allQueryItemValues(), QUrl::authority(), canonicalHost(), clear(), QUrl::encodedFragment(), QUrl::encodedPassword(), QUrl::encodedPath(), QUrl::encodedQuery(), QUrl::encodedQueryItems(), QUrl::encodedQueryItemValue(), QUrl::encodedUserName(), QUrl::fragment(), QUrl::hasEncodedQueryItem(), QUrl::hasFragment(), QUrl::hasQuery(), QUrl::host(), QUrl::isEmpty(), QUrl::isLocalFile(), QUrl::isParentOf(), QUrl::isRelative(), QUrl::isValid(), normalized(), QUrl::operator<(), QUrl::operator==(), parse(), QUrl::password(), QUrl::path(), QUrl::port(), QUrl::queryItems(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), QUrl::resolved(), QUrl::scheme(), QUrl::setAuthority(), QUrl::setEncodedFragment(), QUrl::setEncodedPassword(), QUrl::setEncodedPath(), QUrl::setEncodedQuery(), QUrl::setEncodedQueryItems(), QUrl::setEncodedUserName(), QUrl::setFragment(), QUrl::setHost(), QUrl::setPassword(), QUrl::setPath(), QUrl::setPort(), QUrl::setQueryItems(), QUrl::setScheme(), QUrl::setUserInfo(), QUrl::setUserName(), toEncoded(), QUrl::toString(), QUrl::userInfo(), QUrl::userName(), and validate().

userName

QString QUrlPrivate::userName

Definition at line 357 of file qurl.cpp.

Referenced by clear(), ensureEncodedParts(), QUrl::isEmpty(), setEncodedUserInfo(), QUrl::setEncodedUserName(), setUserInfo(), QUrl::setUserName(), toEncoded(), userInfo(), QUrl::userName(), and validate().

valueDelimiter

char QUrlPrivate::valueDelimiter

Definition at line 378 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), clear(), queryItem(), QUrl::queryValueDelimiter(), QUrl::setEncodedQueryItems(), QUrl::setQueryDelimiters(), and QUrl::setQueryItems().

---

The documentation for this class was generated from the following file:

• /src/corelib/io/qurl.cpp