qurlquery.cpp

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/corelib/io/qurlquery.cpp

Source code

Switch to Preprocessed file

Line Source Count

1 /**************************************************************************** -

2 ** -

4 ** Contact: https://www.qt.io/licensing/ -

5 ** -

6 ** This file is part of the QtCore module of the Qt Toolkit. -

7 ** -

8 ** $QT_BEGIN_LICENSE:LGPL$ -

9 ** Commercial License Usage -

10 ** Licensees holding valid commercial Qt licenses may use this file in -

11 ** accordance with the commercial license agreement provided with the -

12 ** Software or, alternatively, in accordance with the terms contained in -

13 ** a written agreement between you and The Qt Company. For licensing terms -

14 ** and conditions see https://www.qt.io/terms-conditions. For further -

15 ** information use the contact form at https://www.qt.io/contact-us. -

16 ** -

17 ** GNU Lesser General Public License Usage -

18 ** Alternatively, this file may be used under the terms of the GNU Lesser -

19 ** General Public License version 3 as published by the Free Software -

20 ** Foundation and appearing in the file LICENSE.LGPL3 included in the -

21 ** packaging of this file. Please review the following information to -

22 ** ensure the GNU Lesser General Public License version 3 requirements -

23 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -

24 ** -

25 ** GNU General Public License Usage -

26 ** Alternatively, this file may be used under the terms of the GNU -

27 ** General Public License version 2.0 or (at your option) the GNU General -

28 ** Public license version 3 or any later version approved by the KDE Free -

29 ** Qt Foundation. The licenses are as published by the Free Software -

30 ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -

31 ** included in the packaging of this file. Please review the following -

32 ** information to ensure the GNU General Public License requirements will -

33 ** be met: https://www.gnu.org/licenses/gpl-2.0.html and -

34 ** https://www.gnu.org/licenses/gpl-3.0.html. -

35 ** -

36 ** $QT_END_LICENSE$ -

37 ** -

38 ****************************************************************************/ -

39 -

40 #include "qurlquery.h" -

41 #include "qurl_p.h" -

42 -

43 #include <QtCore/qhashfunctions.h> -

44 #include <QtCore/qstringlist.h> -

45 -

46 #include <algorithm> -

47 -

48 QT_BEGIN_NAMESPACE -

49 -

50 /*! -

51 \class QUrlQuery -

52 \inmodule QtCore -

53 \since 5.0 -

54 -

55 \brief The QUrlQuery class provides a way to manipulate a key-value pairs in -

56 a URL's query. -

57 -

58 \reentrant -

59 \ingroup io -

60 \ingroup network -

61 \ingroup shared -

62 -

63 It is used to parse the query strings found in URLs like the following: -

64 -

65 \image qurl-querystring.png -

66 -

67 Query strings like the above are used to transmit options in the URL and are -

68 usually decoded into multiple key-value pairs. The one above would contain -

69 two entries in its list, with keys "type" and "color". QUrlQuery can also be -

70 used to create a query string suitable for use in QUrl::setQuery() from the -

71 individual components of the query. -

72 -

73 The most common way of parsing a query string is to initialize it in the -

74 constructor by passing it the query string. Otherwise, the setQuery() method -

75 can be used to set the query to be parsed. That method can also be used to -

76 parse a query with non-standard delimiters, after having set them using the -

77 setQueryDelimiters() function. -

78 -

79 The encoded query string can be obtained again using query(). This will take -

80 all the internally-stored items and encode the string using the delimiters. -

81 -

82 \section1 Encoding -

83 -

84 All of the getter methods in QUrlQuery support an optional parameter of type -

85 QUrl::ComponentFormattingOptions, including query(), which dictate how to -

86 encode the data in question. Except for QUrl::FullyDecoded, the returned value must -

87 still be considered a percent-encoded string, as there are certain values -

88 which cannot be expressed in decoded form (like control characters, byte -

89 sequences not decodable to UTF-8). For that reason, the percent character is -

90 always represented by the string "%25". -

91 -

92 \section2 Handling of spaces and plus ("+") -

93 -

94 Web browsers usually encode spaces found in HTML FORM elements to a plus sign -

95 ("+") and plus signs to its percent-encoded form (%2B). However, the Internet -

96 specifications governing URLs do not consider spaces and the plus character -

97 equivalent. -

98 -

99 For that reason, QUrlQuery never encodes the space character to "+" and will -

100 never decode "+" to a space character. Instead, space characters will be -

101 rendered "%20" in encoded form. -

102 -

103 To support encoding like that of HTML forms, QUrlQuery also never decodes the -

104 "%2B" sequence to a plus sign nor encode a plus sign. In fact, any "%2B" or -

105 "+" sequences found in the keys, values, or query string are left exactly -

106 like written (except for the uppercasing of "%2b" to "%2B"). -

107 -

108 \section2 Full decoding -

109 -

110 With QUrl::FullyDecoded formatting, all percent-encoded sequences will be -

111 decoded fully and the '%' character is used to represent itself. -

112 QUrl::FullyDecoded should be used with care, since it may cause data loss. -

113 See the documentation of QUrl::FullyDecoded for information on what data may -

114 be lost. -

115 -

116 This formatting mode should be used only when dealing with text presented to -

117 the user in contexts where percent-encoding is not desired. Note that -

118 QUrlQuery setters and query methods do not support the counterpart -

119 QUrl::DecodedMode parsing, so using QUrl::FullyDecoded to obtain a listing of -

120 keys may result in keys not found in the object. -

121 -

122 \section1 Non-standard delimiters -

123 -

124 By default, QUrlQuery uses an equal sign ("=") to separate a key from its -

125 value, and an ampersand ("&") to separate key-value pairs from each other. It -

126 is possible to change the delimiters that QUrlQuery uses for parsing and for -

127 reconstructing the query by calling setQueryDelimiters(). -

128 -

129 Non-standard delimiters should be chosen from among what RFC 3986 calls -

130 "sub-delimiters". They are: -

131 -

132 \code -

133 sub-delims = "!" / "$" / "&" / "'" / "(" / ")" -

134 / "*" / "+" / "," / ";" / "=" -

135 \endcode -

136 -

137 Use of other characters is not supported and may result in unexpected -

138 behaviour. QUrlQuery does not verify that you passed a valid delimiter. -

139 -

140 \sa QUrl -

141 */ -

142 -

143 /*! -

144 \fn QUrlQuery &QUrlQuery::operator=(QUrlQuery &&other) -

145 -

146 Move-assigns \a other to this QUrlQuery instance. -

147 -

148 \since 5.2 -

149 */ -

150 -

151 typedef QList<QPair<QString, QString> > Map; -

152 -

153 class QUrlQueryPrivate : public QSharedData -

154 { -

155 public: -

156 QUrlQueryPrivate(const QString &query = QString()) -

157 : valueDelimiter(QUrlQuery::defaultQueryValueDelimiter()), -

158 pairDelimiter(QUrlQuery::defaultQueryPairDelimiter()) -

159

{ if (!query.isEmpty()) setQuery(query); }

executed 108 times by 2 tests: end of block

Executed by:

tst_QNetworkReply
tst_QUrlQuery

executed 53 times by 2 tests: setQuery(query);

Executed by:

tst_QNetworkReply
tst_QUrlQuery

!query.isEmpty()	Description
TRUE	evaluated 53 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 55 times by 1 test Evaluated by: tst_QUrlQuery

53-108

160 -

161 QString recodeFromUser(const QString &input) const; -

162 QString recodeToUser(const QString &input, QUrl::ComponentFormattingOptions encoding) const; -

163 -

164 void setQuery(const QString &query); -

165 -

166 void addQueryItem(const QString &key, const QString &value) -

167

{ itemList.append(qMakePair(recodeFromUser(key), recodeFromUser(value))); }

executed 104 times by 1 test: end of block

Executed by:

tst_QUrlQuery

104

168 int findRecodedKey(const QString &key, int from = 0) const -

169 { -

170

for (int i = from; i < itemList.size(); ++i)

i < itemList.size()	Description
TRUE	evaluated 103 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 17 times by 1 test Evaluated by: tst_QUrlQuery

17-103

171

if (itemList.at(i).first == key)

itemList.at(i).first == key	Description
TRUE	evaluated 59 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 44 times by 1 test Evaluated by: tst_QUrlQuery

44-59

172

return i;

executed 59 times by 2 tests: return i;

Executed by:

tst_QNetworkReply
tst_QUrlQuery

173

return itemList.size();

executed 17 times by 1 test: return itemList.size();

Executed by:

tst_QUrlQuery

174 } -

175 Map::const_iterator findKey(const QString &key) const -

176

{ return itemList.constBegin() + findRecodedKey(recodeFromUser(key)); }

executed 39 times by 2 tests: return itemList.constBegin() + findRecodedKey(recodeFromUser(key));

Executed by:

tst_QNetworkReply
tst_QUrlQuery

177 Map::iterator findKey(const QString &key) -

178

{ return itemList.begin() + findRecodedKey(recodeFromUser(key)); }

executed 6 times by 1 test: return itemList.begin() + findRecodedKey(recodeFromUser(key));

Executed by:

tst_QUrlQuery

179 -

180 Map itemList; -

181 QChar valueDelimiter; -

182 QChar pairDelimiter; -

183 }; -

184 -

185 template<> void QSharedDataPointer<QUrlQueryPrivate>::detach() -

186 { -

187

if (d && d->ref.load() == 1)

d	Description
TRUE	evaluated 88 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 55 times by 1 test Evaluated by: tst_QUrlQuery

d->ref.load() == 1	Description
TRUE	evaluated 84 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery

4-88

188

return;

executed 84 times by 1 test: return;

Executed by:

tst_QUrlQuery

189

QUrlQueryPrivate *x = (d ? new QUrlQueryPrivate(*d)

d	Description
TRUE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 55 times by 1 test Evaluated by: tst_QUrlQuery

4-55

190 : new QUrlQueryPrivate); -

191 x->ref.ref(); -

192

if (d && !d->ref.deref())

d	Description
TRUE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 55 times by 1 test Evaluated by: tst_QUrlQuery

!d->ref.deref()	Description
TRUE	never evaluated
FALSE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery

0-55

193

delete d;

never executed: delete d;

194 d = x; -

195

}

executed 59 times by 1 test: end of block

Executed by:

tst_QUrlQuery

196 -

197 // Here's how we do the encoding in QUrlQuery -

198 // The RFC says these are the delimiters: -

199 // gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@" -

200 // sub-delims = "!" / "$" / "&" / "'" / "(" / ")" -

201 // / "*" / "+" / "," / ";" / "=" -

202 // And the definition of query is: -

203 // query = *( pchar / "/" / "?" ) -

204 // pchar = unreserved / pct-encoded / sub-delims / ":" / "@" -

205 // -

206 // The strict definition of query says that it can have unencoded any -

207 // unreserved, sub-delim, ":", "@", "/" and "?". Or, by exclusion, excluded -

208 // delimiters are "#", "[" and "]" -- if those are present, they must be -

209 // percent-encoded. The fact that "[" and "]" should be encoded is probably a -

210 // mistake in the spec, so we ignore it and leave the decoded. -

211 // -

212 // The internal storage in the Map is equivalent to PrettyDecoded. That means -

213 // the getter methods, when called with the default encoding value, will not -

214 // have to recode anything (except for toString()). -

215 // -

216 // QUrlQuery handling of delimiters is quite simple: we never touch any of -

217 // them, except for the "#" character and the pair and value delimiters. Those -

218 // are always kept in their decoded forms. -

219 // -

220 // But when recreating the query string, in toString(), we must take care of -

221 // the special delimiters: the pair and value delimiters, as well as the "#" -

222 // character if unambiguous decoding is requested. -

223 -

224 #define decode(x) ushort(x) -

225 #define leave(x) ushort(0x100 | (x)) -

226 #define encode(x) ushort(0x200 | (x)) -

227 -

228 inline QString QUrlQueryPrivate::recodeFromUser(const QString &input) const -

229 { -

230 // note: duplicated in setQuery() -

231 QString output; -

232 ushort prettyDecodedActions[] = { -

233 decode(pairDelimiter.unicode()), -

234 decode(valueDelimiter.unicode()), -

235 decode('#'), -

236 0 -

237 }; -

238

if (qt_urlRecode(output, input.constData(), input.constData() + input.length(),

qt_urlRecode(o...ecodedActions)	Description
TRUE	evaluated 26 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 242 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

26-242

239

QUrl::DecodeReserved,

qt_urlRecode(o...ecodedActions)	Description
TRUE	evaluated 26 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 242 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

26-242

240

prettyDecodedActions))

qt_urlRecode(o...ecodedActions)	Description
TRUE	evaluated 26 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 242 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

26-242

241

return output;

executed 26 times by 1 test: return output;

Executed by:

tst_QUrlQuery

242

return input;

executed 242 times by 2 tests: return input;

Executed by:

tst_QNetworkReply
tst_QUrlQuery

242

243 } -

244 -

245 inline bool idempotentRecodeToUser(QUrl::ComponentFormattingOptions encoding) -

246 { -

247

return encoding == QUrl::PrettyDecoded;

executed 153 times by 2 tests: return encoding == QUrl::PrettyDecoded;

Executed by:

tst_QNetworkReply
tst_QUrlQuery

153

248 } -

249 -

250 inline QString QUrlQueryPrivate::recodeToUser(const QString &input, QUrl::ComponentFormattingOptions encoding) const -

251 { -

252 // our internal formats are stored in "PrettyDecoded" form -

253 // and there are no ambiguous characters -

254

if (idempotentRecodeToUser(encoding))

idempotentReco...User(encoding)	Description
TRUE	evaluated 42 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 24 times by 1 test Evaluated by: tst_QUrlQuery

24-42

255

return input;

executed 42 times by 2 tests: return input;

Executed by:

tst_QNetworkReply
tst_QUrlQuery

256 -

257

if (!(encoding & QUrl::EncodeDelimiters)) {

!(encoding & Q...odeDelimiters)	Description
TRUE	evaluated 8 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 16 times by 1 test Evaluated by: tst_QUrlQuery

8-16

258 QString output; -

259

if (qt_urlRecode(output, input.constData(), input.constData() + input.length(),

qt_urlRecode(o..., encoding, 0)	Description
TRUE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery

260

encoding, 0))

qt_urlRecode(o..., encoding, 0)	Description
TRUE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery

261

return output;

executed 4 times by 1 test: return output;

Executed by:

tst_QUrlQuery

262

return input;

executed 4 times by 1 test: return input;

Executed by:

tst_QUrlQuery

263 } -

264 -

265 // re-encode the "#" character and the query delimiter pair -

266 ushort actions[] = { encode(pairDelimiter.unicode()), encode(valueDelimiter.unicode()), -

267 encode('#'), 0 }; -

268 QString output; -

269

if (qt_urlRecode(output, input.constData(), input.constData() + input.length(), encoding, actions))

qt_urlRecode(o...ding, actions)	Description
TRUE	evaluated 6 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 10 times by 1 test Evaluated by: tst_QUrlQuery

6-10

270

return output;

executed 6 times by 1 test: return output;

Executed by:

tst_QUrlQuery

271

return input;

executed 10 times by 1 test: return input;

Executed by:

tst_QUrlQuery

272 } -

273 -

274 void QUrlQueryPrivate::setQuery(const QString &query) -

275 { -

276 ushort prettyDecodedActions[] = { -

277 decode(pairDelimiter.unicode()), -

278 decode(valueDelimiter.unicode()), -

279 decode('#'), -

280 0 -

281 }; -

282 -

283 itemList.clear(); -

284 const QChar *pos = query.constData(); -

285 const QChar *const end = pos + query.size(); -

286

while (pos != end) {

pos != end	Description
TRUE	evaluated 79 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 56 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

56-79

287 const QChar *begin = pos; -

288 const QChar *delimiter = 0; -

289

while (pos != end) {

pos != end	Description
TRUE	evaluated 572 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 55 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

55-572

290 // scan for the component parts of this pair -

291

if (!delimiter && pos->unicode() == valueDelimiter)

!delimiter	Description
TRUE	evaluated 344 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 228 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

pos->unicode()...valueDelimiter	Description
TRUE	evaluated 69 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 275 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

69-344

292

delimiter = pos;

executed 69 times by 2 tests: delimiter = pos;

Executed by:

tst_QNetworkReply
tst_QUrlQuery

293

if (pos->unicode() == pairDelimiter)

pos->unicode()... pairDelimiter	Description
TRUE	evaluated 24 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 548 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

24-548

294

break;

executed 24 times by 1 test: break;

Executed by:

tst_QUrlQuery

295 ++pos; -

296

}

executed 548 times by 2 tests: end of block

Executed by:

tst_QNetworkReply
tst_QUrlQuery

548

297

if (!delimiter)

!delimiter	Description
TRUE	evaluated 10 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 69 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

10-69

298

delimiter = pos;

executed 10 times by 1 test: delimiter = pos;

Executed by:

tst_QUrlQuery

299 -

300 // pos is the end of this pair (the end of the string or the pair delimiter) -

301 // delimiter points to the value delimiter or to the end of this pair -

302 -

303 QString key; -

304

if (!qt_urlRecode(key, begin, delimiter,

!qt_urlRecode(...ecodedActions)	Description
TRUE	evaluated 67 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery

12-67

305

QUrl::DecodeReserved,

!qt_urlRecode(...ecodedActions)	Description
TRUE	evaluated 67 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery

12-67

306

prettyDecodedActions))

!qt_urlRecode(...ecodedActions)	Description
TRUE	evaluated 67 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery

12-67

307

key = QString(begin, delimiter - begin);

executed 67 times by 2 tests: key = QString(begin, delimiter - begin);

Executed by:

tst_QNetworkReply
tst_QUrlQuery

308 -

309

if (delimiter == pos) {

delimiter == pos	Description
TRUE	evaluated 10 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 69 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

10-69

310 // the value delimiter wasn't found, store a null value -

311 itemList.append(qMakePair(key, QString())); -

312

} else if (delimiter + 1 == pos) {

executed 10 times by 1 test: end of block

Executed by:

tst_QUrlQuery

delimiter + 1 == pos	Description
TRUE	evaluated 5 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 64 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

5-64

313 // if the delimiter was found but the value is empty, store empty-but-not-null -

314 itemList.append(qMakePair(key, QString(0, Qt::Uninitialized))); -

315

} else {

executed 5 times by 1 test: end of block

Executed by:

tst_QUrlQuery

316 QString value; -

317

if (!qt_urlRecode(value, delimiter + 1, pos,

!qt_urlRecode(...ecodedActions)	Description
TRUE	evaluated 52 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery

12-52

318

QUrl::DecodeReserved,

!qt_urlRecode(...ecodedActions)	Description
TRUE	evaluated 52 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery

12-52

319

prettyDecodedActions))

!qt_urlRecode(...ecodedActions)	Description
TRUE	evaluated 52 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery

12-52

320

value = QString(delimiter + 1, pos - delimiter - 1);

executed 52 times by 2 tests: value = QString(delimiter + 1, pos - delimiter - 1);

Executed by:

tst_QNetworkReply
tst_QUrlQuery

321 itemList.append(qMakePair(key, value)); -

322

}

executed 64 times by 2 tests: end of block

Executed by:

tst_QNetworkReply
tst_QUrlQuery

323 -

324

if (pos != end)

pos != end	Description
TRUE	evaluated 24 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 55 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery

24-55

325

++pos;

executed 24 times by 1 test: ++pos;

Executed by:

tst_QUrlQuery

326

}

executed 79 times by 2 tests: end of block

Executed by:

tst_QNetworkReply
tst_QUrlQuery

327

}

executed 56 times by 2 tests: end of block

Executed by:

tst_QNetworkReply
tst_QUrlQuery

328 -

329 // allow QUrlQueryPrivate to detach from null -

330 template <> inline QUrlQueryPrivate * -

331 QSharedDataPointer<QUrlQueryPrivate>::clone() -

332 { -

333

return d ? new QUrlQueryPrivate(*d) : new QUrlQueryPrivate;

never executed: return d ? new QUrlQueryPrivate(*d) : new QUrlQueryPrivate;

334 } -

335 -

336 /*! -

337 Constructs an empty QUrlQuery object. A query can be set afterwards by -

338 calling setQuery() or items can be added by using addQueryItem(). -

339 -

340 \sa setQuery(), addQueryItem() -

341 */ -

342 QUrlQuery::QUrlQuery() -

343 : d(0) -

344 { -

345

}

executed 60 times by 1 test: end of block

Executed by:

tst_QUrlQuery

346 -

347 /*! -

348 Constructs a QUrlQuery object and parses the \a queryString query string, -

349 using the default query delimiters. To parse a query string using other -

350 delimiters, you should first set them using setQueryDelimiters() and then -

351 set the query with setQuery(). -

352 */ -

353 QUrlQuery::QUrlQuery(const QString &queryString) -

354 : d(queryString.isEmpty() ? 0 : new QUrlQueryPrivate(queryString)) -

355 { -

356

}

executed 49 times by 1 test: end of block

Executed by:

tst_QUrlQuery

357 -

358 /*! -

359 Constructs a QUrlQuery object and parses the query string found in the \a -

360 url URL, using the default query delimiters. To parse a query string using -

361 other delimiters, you should first set them using setQueryDelimiters() and -

362 then set the query with setQuery(). -

363 -

364 \sa QUrl::query() -

365 */ -

366 QUrlQuery::QUrlQuery(const QUrl &url) -

367 : d(0) -

368 { -

369 // use internals to avoid unnecessary recoding -

370 // ### FIXME: actually do it -

371

if (url.hasQuery())

url.hasQuery()	Description
TRUE	evaluated 7 times by 1 test Evaluated by: tst_QNetworkReply
FALSE	never evaluated

0-7

372

d = new QUrlQueryPrivate(url.query());

executed 7 times by 1 test: d = new QUrlQueryPrivate(url.query());

Executed by:

tst_QNetworkReply

373

}

executed 7 times by 1 test: end of block

Executed by:

tst_QNetworkReply

374 -

375 /*! -

376 Copies the contents of the \a other QUrlQuery object, including the query -

377 delimiters. -

378 */ -

379 QUrlQuery::QUrlQuery(const QUrlQuery &other) -

380 : d(other.d) -

381 { -

382

}

executed 5 times by 1 test: end of block

Executed by:

tst_QUrlQuery

383 -

384 /*! -

385 Copies the contents of the \a other QUrlQuery object, including the query -

386 delimiters. -

387 */ -

388 QUrlQuery &QUrlQuery::operator =(const QUrlQuery &other) -

389 { -

390 d = other.d; -

391

return *this;

executed 2 times by 1 test: return *this;

Executed by:

tst_QUrlQuery

392 } -

393 -

394 /*! -

395 \fn void QUrlQuery::swap(QUrlQuery &other) -

396 -

397 Swaps this URL query instance with \a other. This function is very -

398 fast and never fails. -

399 */ -

400 -

401 /*! -

402 Destroys this QUrlQuery object. -

403 */ -

404 QUrlQuery::~QUrlQuery() -

405 { -

406 // d auto-deletes -

407 } -

408 -

409 /*! -

410 Returns \c true if this object and the \a other object contain the same -

411 contents, in the same order, and use the same query delimiters. -

412 */ -

413 bool QUrlQuery::operator ==(const QUrlQuery &other) const -

414 { -

415

if (d == other.d)

d == other.d	Description
TRUE	evaluated 7 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 10 times by 1 test Evaluated by: tst_QUrlQuery

7-10

416

return true;

executed 7 times by 1 test: return true;

Executed by:

tst_QUrlQuery

417 if (d && other.d) -

418 // keep in sync with qHash(QUrlQuery): -

419

return d->valueDelimiter == other.d->valueDelimiter &&

executed 8 times by 1 test:

return d->valueDelimiter == other.d->valueDelimiter && d->pairDelimiter == other.d->pairDelimiter && d->itemList == other.d->itemList;

Executed by:

tst_QUrlQuery

420

d->pairDelimiter == other.d->pairDelimiter &&

executed 8 times by 1 test:

return d->valueDelimiter == other.d->valueDelimiter && d->pairDelimiter == other.d->pairDelimiter && d->itemList == other.d->itemList;

Executed by:

tst_QUrlQuery

421

d->itemList == other.d->itemList;

executed 8 times by 1 test:

return d->valueDelimiter == other.d->valueDelimiter && d->pairDelimiter == other.d->pairDelimiter && d->itemList == other.d->itemList;

Executed by:

tst_QUrlQuery

422

return false;

executed 2 times by 1 test: return false;

Executed by:

tst_QUrlQuery

423 } -

424 -

425 /*! -

426 \since 5.6 -

427 \relates QUrlQuery -

428 -

429 Returns the hash value for \a key, -

430 using \a seed to seed the calculation. -

431 */ -

432 uint qHash(const QUrlQuery &key, uint seed) Q_DECL_NOTHROW -

433 { -

434

if (const QUrlQueryPrivate *d = key.d) {

const QUrlQuer...ate *d = key.d	Description
TRUE	evaluated 2 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery

2-4

435 QtPrivate::QHashCombine hash; -

436 // keep in sync with operator==: -

437 seed = hash(seed, d->valueDelimiter); -

438 seed = hash(seed, d->pairDelimiter); -

439 seed = hash(seed, d->itemList); -

440

}

executed 2 times by 1 test: end of block

Executed by:

tst_QUrlQuery

441

return seed;

executed 6 times by 1 test: return seed;

Executed by:

tst_QUrlQuery

442 } -

443 -

444 /*! -

445 Returns \c true if this QUrlQuery object contains no key-value pairs, such as -

446 after being default-constructed or after parsing an empty query string. -

447 -

448 \sa setQuery(), clear() -

449 */ -

450 bool QUrlQuery::isEmpty() const -

451 { -

452

return d ? d->itemList.isEmpty() : true;

executed 37 times by 1 test: return d ? d->itemList.isEmpty() : true;

Executed by:

tst_QUrlQuery

453 } -

454 -

455 /*! -

456 \internal -

457 */ -

458 bool QUrlQuery::isDetached() const -

459 { -

460

return d && d->ref.load() == 1;

executed 4 times by 1 test: return d && d->ref.load() == 1;

Executed by:

tst_QUrlQuery

461 } -

462 -

463 /*! -

464 Clears this QUrlQuery object by removing all of the key-value pairs -

465 currently stored. If the query delimiters have been changed, this function -

466 will leave them with their changed values. -

467 -

468 \sa isEmpty(), setQueryDelimiters() -

469 */ -

470 void QUrlQuery::clear() -

471 { -

472

if (d.constData())

d.constData()	Description
TRUE	evaluated 16 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 5 times by 1 test Evaluated by: tst_QUrlQuery

5-16

473

d->itemList.clear();

executed 16 times by 1 test: d->itemList.clear();

Executed by:

tst_QUrlQuery

474

}

executed 21 times by 1 test: end of block

Executed by:

tst_QUrlQuery

475 -

476 /*! -

477 Parses the query string in \a queryString and sets the internal items to -

478 the values found there. If any delimiters have been specified with -

479 setQueryDelimiters(), this function will use them instead of the default -

480 delimiters to parse the string. -

481 */ -

482 void QUrlQuery::setQuery(const QString &queryString) -

483 { -

484 d->setQuery(queryString); -

485

}

executed 3 times by 1 test: end of block

Executed by:

tst_QUrlQuery

486 -

487 static void recodeAndAppend(QString &to, const QString &input, -

488 QUrl::ComponentFormattingOptions encoding, const ushort *tableModifications) -

489 { -

490

if (!qt_urlRecode(to, input.constData(), input.constData() + input.length(), encoding, tableModifications))

!qt_urlRecode(...Modifications)	Description
TRUE	evaluated 123 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 32 times by 1 test Evaluated by: tst_QUrlQuery

32-123

491

to += input;

executed 123 times by 1 test: to += input;

Executed by:

tst_QUrlQuery

123

492

}

executed 155 times by 1 test: end of block

Executed by:

tst_QUrlQuery

155

493 -

494 /*! -

495 Returns the reconstructed query string, formed from the key-value pairs -

496 currently stored in this QUrlQuery object and separated by the query -

497 delimiters chosen for this object. The keys and values are encoded using -

498 the options given by the \a encoding parameter. -

499 -

500 For this function, the only ambiguous delimiter is the hash ("#"), as in -

501 URLs it is used to separate the query string from the fragment that may -

502 follow. -

503 -

504 The order of the key-value pairs in the returned string is exactly the same -

505 as in the original query. -

506 -

507 \sa setQuery(), QUrl::setQuery(), QUrl::fragment(), {encoding}{Encoding} -

508 */ -

509 QString QUrlQuery::query(QUrl::ComponentFormattingOptions encoding) const -

510 { -

511

if (!d)

!d	Description
TRUE	evaluated 2 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 66 times by 1 test Evaluated by: tst_QUrlQuery

2-66

512

return QString();

executed 2 times by 1 test: return QString();

Executed by:

tst_QUrlQuery

513 -

514 // unlike the component encoding, for the whole query we need to modify a little: -

515 // - the "#" character is unambiguous, so we encode it in EncodeDelimiters mode -

516 // - the query delimiter pair must always be encoded -

517 -

518 // start with what's always encoded -

519 ushort tableActions[] = { -

520 encode(d->pairDelimiter.unicode()), // 0 -

521 encode(d->valueDelimiter.unicode()), // 1 -

522 0, // 2 -

523 0 -

524 }; -

525

if (encoding & QUrl::EncodeDelimiters) {

encoding & QUr...codeDelimiters	Description
TRUE	evaluated 6 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 60 times by 1 test Evaluated by: tst_QUrlQuery

6-60

526 tableActions[2] = encode('#'); -

527

}

executed 6 times by 1 test: end of block

Executed by:

tst_QUrlQuery

528 -

529 QString result; -

530 Map::const_iterator it = d->itemList.constBegin(); -

531 Map::const_iterator end = d->itemList.constEnd(); -

532 -

533 { -

534 int size = 0; -

535

for ( ; it != end; ++it)

it != end	Description
TRUE	evaluated 81 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 66 times by 1 test Evaluated by: tst_QUrlQuery

66-81

536

size += it->first.length() + 1 + it->second.length() + 1;

executed 81 times by 1 test: size += it->first.length() + 1 + it->second.length() + 1;

Executed by:

tst_QUrlQuery

537 result.reserve(size + size / 4); -

538 } -

539 -

540

for (it = d->itemList.constBegin(); it != end; ++it) {

it != end	Description
TRUE	evaluated 81 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 66 times by 1 test Evaluated by: tst_QUrlQuery

66-81

541

if (!result.isEmpty())

!result.isEmpty()	Description
TRUE	evaluated 15 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 66 times by 1 test Evaluated by: tst_QUrlQuery

15-66

542

result += QChar(d->pairDelimiter);

executed 15 times by 1 test: result += QChar(d->pairDelimiter);

Executed by:

tst_QUrlQuery

543 recodeAndAppend(result, it->first, encoding, tableActions); -

544

if (!it->second.isNull()) {

!it->second.isNull()	Description
TRUE	evaluated 74 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 7 times by 1 test Evaluated by: tst_QUrlQuery

7-74

545 result += QChar(d->valueDelimiter); -

546 recodeAndAppend(result, it->second, encoding, tableActions); -

547

}

executed 74 times by 1 test: end of block

Executed by:

tst_QUrlQuery

548

}

executed 81 times by 1 test: end of block

Executed by:

tst_QUrlQuery

549

return result;

executed 66 times by 1 test: return result;

Executed by:

tst_QUrlQuery

550 } -

551 -

552 /*! -

553 Sets the characters used for delimiting between keys and values, -

554 and between key-value pairs in the URL's query string. The default -

555 value delimiter is '=' and the default pair delimiter is '&'. -

556 -

557 \image qurl-querystring.png -

558 -

559 \a valueDelimiter will be used for separating keys from values, -

560 and \a pairDelimiter will be used to separate key-value pairs. -

561 Any occurrences of these delimiting characters in the encoded -

562 representation of the keys and values of the query string are -

563 percent encoded when returned in query(). -

564 -

565 If \a valueDelimiter is set to '(' and \a pairDelimiter is ')', -

566 the above query string would instead be represented like this: -

567 -

568 \snippet code/src_corelib_io_qurl.cpp 4 -

569 -

570 \note Non-standard delimiters should be chosen from among what RFC 3986 calls -

571 "sub-delimiters". They are: -

572 -

573 \code -

574 sub-delims = "!" / "$" / "&" / "'" / "(" / ")" -

575 / "*" / "+" / "," / ";" / "=" -

576 \endcode -

577 -

578 Use of other characters is not supported and may result in unexpected -

579 behaviour. This method does not verify that you passed a valid delimiter. -

580 -

581 \sa queryValueDelimiter(), queryPairDelimiter() -

582 */ -

583 void QUrlQuery::setQueryDelimiters(QChar valueDelimiter, QChar pairDelimiter) -

584 { -

585 d->valueDelimiter = valueDelimiter.unicode(); -

586 d->pairDelimiter = pairDelimiter.unicode(); -

587

}

executed 3 times by 1 test: end of block

Executed by:

tst_QUrlQuery

588 -

589 /*! -

590 Returns the character used to delimit between keys and values when -

591 reconstructing the query string in query() or when parsing in setQuery(). -

592 -

593 \sa setQueryDelimiters(), queryPairDelimiter() -

594 */ -

595 QChar QUrlQuery::queryValueDelimiter() const -

596 { -

597

return d ? d->valueDelimiter : defaultQueryValueDelimiter();

executed 2 times by 1 test: return d ? d->valueDelimiter : defaultQueryValueDelimiter();

Executed by:

tst_QUrlQuery

598 } -

599 -

600 /*! -

601 Returns the character used to delimit between keys-value pairs when -

602 reconstructing the query string in query() or when parsing in setQuery(). -

603 -

604 \sa setQueryDelimiters(), queryValueDelimiter() -

605 */ -

606 QChar QUrlQuery::queryPairDelimiter() const -

607 { -

608

return d ? d->pairDelimiter : defaultQueryPairDelimiter();

executed 2 times by 1 test: return d ? d->pairDelimiter : defaultQueryPairDelimiter();

Executed by:

tst_QUrlQuery

609 } -

610 -

611 /*! -

612 Sets the items in this QUrlQuery object to \a query. The order of the -

613 elements in \a query is preserved. -

614 -

615 \note This method does not treat spaces (ASCII 0x20) and plus ("+") signs -

616 as the same, like HTML forms do. If you need spaces to be represented as -

617 plus signs, use actual plus signs. -

618 -

619 \sa queryItems(), isEmpty() -

620 */ -

621 void QUrlQuery::setQueryItems(const QList<QPair<QString, QString> > &query) -

622 { -

623 clear(); -

624

if (query.isEmpty())

query.isEmpty()	Description
TRUE	evaluated 1 time by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 9 times by 1 test Evaluated by: tst_QUrlQuery

1-9

625

return;

executed 1 time by 1 test: return;

Executed by:

tst_QUrlQuery

626 -

627 QUrlQueryPrivate *dd = d; -

628 QList<QPair<QString, QString> >::const_iterator it = query.constBegin(), -

629 end = query.constEnd(); -

630

for ( ; it != end; ++it)

it != end	Description
TRUE	evaluated 24 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 9 times by 1 test Evaluated by: tst_QUrlQuery

9-24

631

dd->addQueryItem(it->first, it->second);

executed 24 times by 1 test: dd->addQueryItem(it->first, it->second);

Executed by:

tst_QUrlQuery

632

}

executed 9 times by 1 test: end of block

Executed by:

tst_QUrlQuery

633 -

634 /*! -

635 Returns the query string of the URL, as a map of keys and values, using the -

636 options specified in \a encoding to encode the items. The order of the -

637 elements is the same as the one found in the query string or set with -

638 setQueryItems(). -

639 -

640 \sa setQueryItems(), {encoding}{Encoding} -

641 */ -

642 QList<QPair<QString, QString> > QUrlQuery::queryItems(QUrl::ComponentFormattingOptions encoding) const -

643 { -

644

if (!d)

!d	Description
TRUE	evaluated 5 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 87 times by 1 test Evaluated by: tst_QUrlQuery

5-87

645

return QList<QPair<QString, QString> >();

executed 5 times by 1 test: return QList<QPair<QString, QString> >();

Executed by:

tst_QUrlQuery

646

if (idempotentRecodeToUser(encoding))

idempotentReco...User(encoding)	Description
TRUE	evaluated 76 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 11 times by 1 test Evaluated by: tst_QUrlQuery

11-76

647

return d->itemList;

executed 76 times by 1 test: return d->itemList;

Executed by:

tst_QUrlQuery

648 -

649 QList<QPair<QString, QString> > result; -

650 Map::const_iterator it = d->itemList.constBegin(); -

651 Map::const_iterator end = d->itemList.constEnd(); -

652 result.reserve(d->itemList.count()); -

653

for ( ; it != end; ++it)

it != end	Description
TRUE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 11 times by 1 test Evaluated by: tst_QUrlQuery

11-12

654

result << qMakePair(d->recodeToUser(it->first, encoding),

executed 12 times by 1 test: result << qMakePair(d->recodeToUser(it->first, encoding), d->recodeToUser(it->second, encoding));

Executed by:

tst_QUrlQuery

655

d->recodeToUser(it->second, encoding));

executed 12 times by 1 test: result << qMakePair(d->recodeToUser(it->first, encoding), d->recodeToUser(it->second, encoding));

Executed by:

tst_QUrlQuery

656

return result;

executed 11 times by 1 test: return result;

Executed by:

tst_QUrlQuery

657 } -

658 -

659 /*! -

660 Returns \c true if there is a query string pair whose key is equal -

661 to \a key from the URL. -

662 -

663 \sa addQueryItem(), queryItemValue() -

664 */ -

665 bool QUrlQuery::hasQueryItem(const QString &key) const -

666 { -

667

if (!d)

!d	Description
TRUE	evaluated 4 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 16 times by 1 test Evaluated by: tst_QUrlQuery

4-16

668

return false;

executed 4 times by 1 test: return false;

Executed by:

tst_QUrlQuery

669

return d->findKey(key) != d->itemList.constEnd();

executed 16 times by 1 test: return d->findKey(key) != d->itemList.constEnd();

Executed by:

tst_QUrlQuery

670 } -

671 -

672 /*! -

673 Appends the pair \a key = \a value to the end of the query string of the -

674 URL. This method does not overwrite existing items that might exist with -

675 the same key. -

676 -

677 \note This method does not treat spaces (ASCII 0x20) and plus ("+") signs -

678 as the same, like HTML forms do. If you need spaces to be represented as -

679 plus signs, use actual plus signs. -

680 -

681 \sa hasQueryItem(), queryItemValue() -

682 */ -

683 void QUrlQuery::addQueryItem(const QString &key, const QString &value) -

684 { -

685 d->addQueryItem(key, value); -

686

}

executed 80 times by 1 test: end of block

Executed by:

tst_QUrlQuery

687 -

688 /*! -

689 Returns the query value associated with key \a key from the URL, using the -

690 options specified in \a encoding to encode the return value. If the key \a -

691 key is not found, this function returns an empty string. If you need to -

692 distinguish between an empty value and a non-existent key, you should check -

693 for the key's presence first using hasQueryItem(). -

694 -

695 If the key \a key is multiply defined, this function will return the first -

696 one found, in the order they were present in the query string or added -

697 using addQueryItem(). -

698 -

699 \sa addQueryItem(), allQueryItemValues(), {encoding}{Encoding} -

700 */ -

701 QString QUrlQuery::queryItemValue(const QString &key, QUrl::ComponentFormattingOptions encoding) const -

702 { -

703 QString result; -

704

if (d) {

d	Description
TRUE	evaluated 23 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	evaluated 3 times by 1 test Evaluated by: tst_QUrlQuery

3-23

705 Map::const_iterator it = d->findKey(key); -

706

if (it != d->itemList.constEnd())

it != d->itemList.constEnd()	Description
TRUE	evaluated 23 times by 2 tests Evaluated by: tst_QNetworkReply tst_QUrlQuery
FALSE	never evaluated

0-23

707

result = d->recodeToUser(it->second, encoding);

executed 23 times by 2 tests: result = d->recodeToUser(it->second, encoding);

Executed by:

tst_QNetworkReply
tst_QUrlQuery

708

}

executed 23 times by 2 tests: end of block

Executed by:

tst_QNetworkReply
tst_QUrlQuery

709

return result;

executed 26 times by 2 tests: return result;

Executed by:

tst_QNetworkReply
tst_QUrlQuery

710 } -

711 -

712 /*! -

713 Returns the a list of query string values whose key is equal to \a key from -

714 the URL, using the options specified in \a encoding to encode the return -

715 value. If the key \a key is not found, this function returns an empty list. -

716 -

717 \sa queryItemValue(), addQueryItem() -

718 */ -

719 QStringList QUrlQuery::allQueryItemValues(const QString &key, QUrl::ComponentFormattingOptions encoding) const -

720 { -

721 QStringList result; -

722

if (d) {

d	Description
TRUE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 3 times by 1 test Evaluated by: tst_QUrlQuery

3-12

723 QString encodedKey = d->recodeFromUser(key); -

724 int idx = d->findRecodedKey(encodedKey); -

725

while (idx < d->itemList.size()) {

idx < d->itemList.size()	Description
TRUE	evaluated 19 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 12 times by 1 test Evaluated by: tst_QUrlQuery

12-19

726 result << d->recodeToUser(d->itemList.at(idx).second, encoding); -

727 idx = d->findRecodedKey(encodedKey, idx + 1); -

728

}

executed 19 times by 1 test: end of block

Executed by:

tst_QUrlQuery

729

}

executed 12 times by 1 test: end of block

Executed by:

tst_QUrlQuery

730

return result;

executed 15 times by 1 test: return result;

Executed by:

tst_QUrlQuery

731 } -

732 -

733 /*! -

734 Removes the query string pair whose key is equal to \a key from the URL. If -

735 there are multiple items with a key equal to \a key, it removes the first -

736 item in the order they were present in the query string or added with -

737 addQueryItem(). -

738 -

739 \sa removeAllQueryItems() -

740 */ -

741 void QUrlQuery::removeQueryItem(const QString &key) -

742 { -

743

if (d.constData()) {

d.constData()	Description
TRUE	evaluated 6 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	never evaluated

0-6

744 Map::iterator it = d->findKey(key); -

745

if (it != d->itemList.end())

it != d->itemList.end()	Description
TRUE	evaluated 5 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	evaluated 1 time by 1 test Evaluated by: tst_QUrlQuery

1-5

746

d->itemList.erase(it);

executed 5 times by 1 test: d->itemList.erase(it);

Executed by:

tst_QUrlQuery

747

}

executed 6 times by 1 test: end of block

Executed by:

tst_QUrlQuery

748

}

executed 6 times by 1 test: end of block

Executed by:

tst_QUrlQuery

749 -

750 /*! -

751 Removes all the query string pairs whose key is equal to \a key -

752 from the URL. -

753 -

754 \sa removeQueryItem() -

755 */ -

756 void QUrlQuery::removeAllQueryItems(const QString &key) -

757 { -

758

if (d.constData()) {

d.constData()	Description
TRUE	evaluated 3 times by 1 test Evaluated by: tst_QUrlQuery
FALSE	never evaluated

0-3

759 const QString encodedKey = d->recodeFromUser(key); -

760 auto firstEqualsEncodedKey = [&encodedKey](const QPair<QString, QString> &item) { -

761

return item.first == encodedKey;

executed 14 times by 1 test: return item.first == encodedKey;

Executed by:

tst_QUrlQuery

762 }; -

763 const auto end = d->itemList.end(); -

764 d->itemList.erase(std::remove_if(d->itemList.begin(), end, firstEqualsEncodedKey), end); -

765

}

executed 3 times by 1 test: end of block

Executed by:

tst_QUrlQuery

766

}

executed 3 times by 1 test: end of block

Executed by:

tst_QUrlQuery

767 -

768 /*! -

769 \fn QChar QUrlQuery::defaultQueryValueDelimiter() -

770 Returns the default character for separating keys from values in the query, -

771 an equal sign ("="). -

772 -

773 \sa setQueryDelimiters(), queryValueDelimiter(), defaultQueryPairDelimiter() -

774 */ -

775 -

776 /*! -

777 \fn QChar QUrlQuery::defaultQueryPairDelimiter() -

778 Returns the default character for separating keys-value pairs from each -

779 other, an ampersand ("&"). -

780 -

781 \sa setQueryDelimiters(), queryPairDelimiter(), defaultQueryValueDelimiter() -

782 */ -

783 -

784 /*! -

785 \typedef QUrlQuery::DataPtr -

786 \internal -

787 */ -

788 -

789 /*! -

790 \fn DataPtr &QUrlQuery::data_ptr() -

791 \internal -

792 */ -

793 -

794 /*! -

795 \fn QString QUrlQuery::toString(QUrl::ComponentFormattingOptions encoding = QUrl::PrettyDecoded) const -

796 -

797 Returns this QUrlQuery as a QString. \a encoding can be used to specify the URL string encoding of the return value. -

798 */ -

799 -

800 /*! -

801 \fn bool QUrlQuery::operator!=(const QUrlQuery &other) const -

802 -

803 Returns \c true if \a other is not equal to this QUrlQuery. Otherwise, returns \c false. -

804 -

805 \sa operator==() -

806 */ -

807 QT_END_NAMESPACE -

Source code

Switch to Preprocessed file

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9