KTextTemplate

safestring.cpp
1/*
2 This file is part of the KTextTemplate library
3
4 SPDX-FileCopyrightText: 2009, 2010 Stephen Kelly <steveire@gmail.com>
5
6 SPDX-License-Identifier: LGPL-2.1-or-later
7
8*/
9
10#include "safestring.h"
11
12#include <QStringList>
13
14using namespace KTextTemplate;
15
16SafeString::SafeString()
17 : m_nestedString(this)
18 , m_safety(IsNotSafe)
19 , m_needsescape(false)
20{
21}
22
23SafeString::SafeString(const KTextTemplate::SafeString &safeString)
24 : m_nestedString(safeString.get(), this)
25 , m_safety(safeString.m_safety)
26 , m_needsescape(safeString.m_needsescape)
27{
28}
29
30SafeString::SafeString(const QString &str, bool safe)
31 : m_nestedString(str, this)
32 , m_safety(safe ? IsSafe : IsNotSafe)
33 , m_needsescape(false)
34{
35}
36
37SafeString::SafeString(const QString &str, Safety safety)
38 : m_nestedString(str, this)
39 , m_safety(safety)
40 , m_needsescape(false)
41{
42}
43
44SafeString::~SafeString() = default;
45
46void SafeString::setNeedsEscape(bool needsEscape)
47{
48 m_needsescape = needsEscape;
49}
50
51bool SafeString::needsEscape() const
52{
53 return m_needsescape;
54}
55
56void SafeString::setSafety(KTextTemplate::SafeString::Safety safety)
57{
58 m_safety = safety;
59}
60
61bool SafeString::isSafe() const
62{
63 return m_safety == IsSafe;
64}
65
66SafeString::NestedString::NestedString(SafeString *safeString)
67 : m_safeString(safeString)
68{
69}
70
71SafeString::NestedString::NestedString(const QString &content, SafeString *safeString)
72 : QString(content)
73 , m_safeString(safeString)
74{
75}
76
77SafeString &SafeString::operator=(const SafeString &str)
78{
79 if (&str == this)
80 return *this;
81 m_nestedString = str.m_nestedString;
82 m_nestedString.m_safeString = this;
83 m_safety = str.m_safety;
84 m_needsescape = str.m_needsescape;
85 return *this;
86}
87
88SafeString SafeString::operator+(const QString &str)
89{
90 return {static_cast<QString>(m_nestedString) + str, IsNotSafe};
91}
92
93SafeString SafeString::operator+(const SafeString &str)
94{
95 if (!str.isSafe())
96 return {static_cast<QString>(m_nestedString) + static_cast<QString>(str.get()), IsNotSafe};
97 return {static_cast<QString>(m_nestedString) + static_cast<QString>(str.get()), m_safety};
98}
99
100SafeString &SafeString::operator+=(const QString &str)
101{
102 m_safety = IsNotSafe;
103
104 m_nestedString += str;
105 return *this;
106}
107
108SafeString &SafeString::operator+=(const SafeString &str)
109{
110 if (!str.isSafe())
111 m_safety = IsNotSafe;
112
113 m_nestedString += str.get();
114 return *this;
115}
116
117bool SafeString::operator==(const KTextTemplate::SafeString &other) const
118{
119 // Don't compare safety or account for future escaping here.
120 // See TestBuiltins testEscaping
121 return m_nestedString == other.get();
122}
123
124bool SafeString::operator==(const QString &other) const
125{
126 return m_nestedString == other;
127}
128
129SafeString &SafeString::NestedString::append(const SafeString &str)
130{
131 QString::append(str.get());
132 if (!str.isSafe())
133 m_safeString->m_safety = IsNotSafe;
134
135 return *m_safeString;
136}
137
138SafeString &SafeString::NestedString::append(const QString &str)
139{
140 QString::append(str);
141 m_safeString->m_safety = IsNotSafe;
142 return *m_safeString;
143}
144
145SafeString &SafeString::NestedString::append(const QLatin1String &str)
146{
147 QString::append(str);
148 m_safeString->m_safety = IsNotSafe;
149 return *m_safeString;
150}
151
152SafeString &SafeString::NestedString::append(const QChar ch)
153{
154 QString::append(ch);
155 m_safeString->m_safety = IsNotSafe;
156 return *m_safeString;
157}
158
159void SafeString::NestedString::chop(int n)
160{
161 QString::chop(n);
162 m_safeString->m_safety = IsNotSafe;
163}
164
165SafeString &SafeString::NestedString::fill(QChar ch, int size)
166{
167 QString::fill(ch, size);
168 m_safeString->m_safety = IsNotSafe;
169 return *m_safeString;
170}
171
172SafeString &SafeString::NestedString::insert(int position, const KTextTemplate::SafeString &str)
173{
174 QString::insert(position, str.get());
175 if (!str.isSafe())
176 m_safeString->m_safety = IsNotSafe;
177
178 return *m_safeString;
179}
180
181SafeString &SafeString::NestedString::insert(int position, const QString &str)
182{
183 QString::insert(position, str);
184 return *m_safeString;
185}
186
187SafeString &SafeString::NestedString::insert(int position, const QLatin1String &str)
188{
189 QString::insert(position, str);
190 return *m_safeString;
191}
192
193SafeString &SafeString::NestedString::insert(int position, const QChar *unicode, int size)
194{
195 QString::insert(position, unicode, size);
196 return *m_safeString;
197}
198
199SafeString &SafeString::NestedString::insert(int position, QChar ch)
200{
201 QString::insert(position, ch);
202 return *m_safeString;
203}
204
205SafeString SafeString::NestedString::left(int n) const
206{
207 return {QString::left(n), m_safeString->m_safety};
208}
209
210SafeString SafeString::NestedString::leftJustified(int width, QChar fill, bool truncate) const
211{
212 return {QString::leftJustified(width, fill, truncate), m_safeString->m_safety};
213}
214
215SafeString SafeString::NestedString::mid(int position, int n) const
216{
217 return {QString::mid(position, n), m_safeString->m_safety};
218}
219
220SafeString SafeString::NestedString::normalized(QString::NormalizationForm mode) const
221{
222 return {QString::normalized(mode), m_safeString->m_safety};
223}
224
225SafeString SafeString::NestedString::normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version) const
226{
227 return {QString::normalized(mode, version), m_safeString->m_safety};
228}
229
230SafeString &SafeString::NestedString::prepend(const KTextTemplate::SafeString &str)
231{
232 QString::prepend(str.get());
233 if (!str.isSafe())
234 m_safeString->m_safety = IsNotSafe;
235
236 return *m_safeString;
237}
238
239SafeString &SafeString::NestedString::prepend(const QString &str)
240{
241 QString::prepend(str);
242 m_safeString->m_safety = IsNotSafe;
243 return *m_safeString;
244}
245
246SafeString &SafeString::NestedString::prepend(const QLatin1String &str)
247{
248 QString::prepend(str);
249 m_safeString->m_safety = IsNotSafe;
250 return *m_safeString;
251}
252
253SafeString &SafeString::NestedString::prepend(QChar ch)
254{
255 QString::prepend(ch);
256 m_safeString->m_safety = IsNotSafe;
257 return *m_safeString;
258}
259
260void SafeString::NestedString::push_back(const KTextTemplate::SafeString &other)
261{
262 QString::push_back(other.get());
263 m_safeString->m_safety = other.m_safety;
264}
265
266void SafeString::NestedString::push_front(const KTextTemplate::SafeString &other)
267{
268 QString::push_front(other.get());
269 m_safeString->m_safety = other.m_safety;
270}
271
272SafeString &SafeString::NestedString::remove(int position, int n)
273{
274 QString::remove(position, n);
275 m_safeString->m_safety = IsNotSafe;
276 return *m_safeString;
277}
278
279SafeString &SafeString::NestedString::remove(QChar ch, Qt::CaseSensitivity cs)
280{
281 QString::remove(ch, cs);
282 m_safeString->m_safety = IsNotSafe;
283 return *m_safeString;
284}
285
286SafeString &SafeString::NestedString::remove(const KTextTemplate::SafeString &str, Qt::CaseSensitivity cs)
287{
288 QString::remove(str, cs);
289 m_safeString->m_safety = IsNotSafe;
290 return *m_safeString;
291}
292
293SafeString &SafeString::NestedString::remove(const QString &str, Qt::CaseSensitivity cs)
294{
295 QString::remove(str, cs);
296 m_safeString->m_safety = IsNotSafe;
297 return *m_safeString;
298}
299
300SafeString &SafeString::NestedString::remove(const QRegularExpression &rx)
301{
302 QString::remove(rx);
303 m_safeString->m_safety = IsNotSafe;
304 return *m_safeString;
305}
306
307SafeString SafeString::NestedString::repeated(int times) const
308{
309 return {QString::repeated(times), m_safeString->m_safety};
310}
311
312SafeString &SafeString::NestedString::replace(int position, int n, const KTextTemplate::SafeString &after)
313{
314 QString::replace(position, n, after.get());
315 m_safeString->m_safety = after.m_safety;
316 return *m_safeString;
317}
318
319SafeString &SafeString::NestedString::replace(int position, int n, const QString &after)
320{
321 QString::replace(position, n, after);
322 m_safeString->m_safety = IsNotSafe;
323 return *m_safeString;
324}
325
326SafeString &SafeString::NestedString::replace(int position, int n, const QChar *unicode, int size)
327{
328 QString::replace(position, n, unicode, size);
329 m_safeString->m_safety = IsNotSafe;
330 return *m_safeString;
331}
332
333SafeString &SafeString::NestedString::replace(int position, int n, QChar after)
334{
335 QString::replace(position, n, after);
336 m_safeString->m_safety = IsNotSafe;
337 return *m_safeString;
338}
339
340SafeString &SafeString::NestedString::replace(const KTextTemplate::SafeString &before, const KTextTemplate::SafeString &after, Qt::CaseSensitivity cs)
341{
342 QString::replace(before.get(), after.get(), cs);
343 m_safeString->m_safety = after.m_safety;
344 return *m_safeString;
345}
346
347SafeString &SafeString::NestedString::replace(const QString &before, const KTextTemplate::SafeString &after, Qt::CaseSensitivity cs)
348{
349 QString::replace(before, after.get(), cs);
350 m_safeString->m_safety = IsNotSafe;
351 return *m_safeString;
352}
353
354SafeString &SafeString::NestedString::replace(const KTextTemplate::SafeString &before, const QString &after, Qt::CaseSensitivity cs)
355{
356 QString::replace(before.get(), after, cs);
357 m_safeString->m_safety = IsNotSafe;
358 return *m_safeString;
359}
360
361SafeString &SafeString::NestedString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs)
362{
363 QString::replace(before, after, cs);
364 m_safeString->m_safety = IsNotSafe;
365 return *m_safeString;
366}
367
368SafeString &SafeString::NestedString::replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs)
369{
370 QString::replace(before, blen, after, alen, cs);
371 m_safeString->m_safety = IsNotSafe;
372 return *m_safeString;
373}
374
375SafeString &SafeString::NestedString::replace(QChar ch, const SafeString &after, Qt::CaseSensitivity cs)
376{
377 QString::replace(ch, after.get(), cs);
378 m_safeString->m_safety = after.m_safety;
379 return *m_safeString;
380}
381
382SafeString &SafeString::NestedString::replace(QChar ch, const QString &after, Qt::CaseSensitivity cs)
383{
384 QString::replace(ch, after, cs);
385 m_safeString->m_safety = IsNotSafe;
386 return *m_safeString;
387}
388
389SafeString &SafeString::NestedString::replace(QChar before, QChar after, Qt::CaseSensitivity cs)
390{
391 QString::replace(before, after, cs);
392 m_safeString->m_safety = IsNotSafe;
393 return *m_safeString;
394}
395
396SafeString &SafeString::NestedString::replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs)
397{
398 QString::replace(before, after, cs);
399 m_safeString->m_safety = IsNotSafe;
400 return *m_safeString;
401}
402
403SafeString &SafeString::NestedString::replace(const QLatin1String &before, const KTextTemplate::SafeString &after, Qt::CaseSensitivity cs)
404{
405 QString::replace(before, after.get(), cs);
406 m_safeString->m_safety = after.m_safety;
407 return *m_safeString;
408}
409
410SafeString &SafeString::NestedString::replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs)
411{
412 QString::replace(before, after, cs);
413 m_safeString->m_safety = IsNotSafe;
414 return *m_safeString;
415}
416
417SafeString &SafeString::NestedString::replace(const KTextTemplate::SafeString &before, const QLatin1String &after, Qt::CaseSensitivity cs)
418{
419 QString::replace(before.get(), after, cs);
420 m_safeString->m_safety = before.m_safety;
421 return *m_safeString;
422}
423
424SafeString &SafeString::NestedString::replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs)
425{
426 QString::replace(before, after, cs);
427 m_safeString->m_safety = IsNotSafe;
428 return *m_safeString;
429}
430
431SafeString &SafeString::NestedString::replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs)
432{
433 QString::replace(c, after, cs);
434 m_safeString->m_safety = IsNotSafe;
435 return *m_safeString;
436}
437
438SafeString &SafeString::NestedString::replace(const QRegularExpression &rx, const KTextTemplate::SafeString &after)
439{
440 QString::replace(rx, after.get());
441 m_safeString->m_safety = after.m_safety;
442 return *m_safeString;
443}
444
445SafeString &SafeString::NestedString::replace(const QRegularExpression &rx, const QString &after)
446{
447 QString::replace(rx, after);
448 m_safeString->m_safety = IsNotSafe;
449 return *m_safeString;
450}
451
452SafeString SafeString::NestedString::right(int n) const
453{
454 return {QString::right(n), m_safeString->m_safety};
455}
456
457SafeString SafeString::NestedString::rightJustified(int width, QChar fill, bool truncate) const
458{
459 return {QString::rightJustified(width, fill, truncate), m_safeString->m_safety};
460}
461
462SafeString SafeString::NestedString::section(const QRegularExpression &reg, int start, int end, QString::SectionFlags flags) const
463{
464 return {QString::section(reg, start, end, flags), m_safeString->m_safety};
465}
466
467SafeString SafeString::NestedString::section(QChar sep, int start, int end, QString::SectionFlags flags) const
468{
469 return {QString::section(sep, start, end, flags), m_safeString->m_safety};
470}
471
472SafeString SafeString::NestedString::section(const KTextTemplate::SafeString &sep, int start, int end, QString::SectionFlags flags) const
473{
474 return {QString::section(sep, start, end, flags), m_safeString->m_safety};
475}
476
477SafeString SafeString::NestedString::section(const QString &sep, int start, int end, QString::SectionFlags flags) const
478{
479 return {QString::section(sep, start, end, flags), m_safeString->m_safety};
480}
481
482SafeString &SafeString::NestedString::setNum(int n, int base)
483{
484 QString::setNum(n, base);
485 m_safeString->m_safety = IsNotSafe;
486 return *m_safeString;
487}
488
489SafeString &SafeString::NestedString::setNum(uint n, int base)
490{
491 QString::setNum(n, base);
492 m_safeString->m_safety = IsNotSafe;
493 return *m_safeString;
494}
495
496SafeString &SafeString::NestedString::setNum(long int n, int base)
497{
498 QString::setNum(n, base);
499 m_safeString->m_safety = IsNotSafe;
500 return *m_safeString;
501}
502
503SafeString &SafeString::NestedString::setNum(ulong n, int base)
504{
505 QString::setNum(n, base);
506 m_safeString->m_safety = IsNotSafe;
507 return *m_safeString;
508}
509
510SafeString &SafeString::NestedString::setNum(qlonglong n, int base)
511{
512 QString::setNum(n, base);
513 m_safeString->m_safety = IsNotSafe;
514 return *m_safeString;
515}
516
517SafeString &SafeString::NestedString::setNum(qulonglong n, int base)
518{
519 QString::setNum(n, base);
520 m_safeString->m_safety = IsNotSafe;
521 return *m_safeString;
522}
523
524SafeString &SafeString::NestedString::setNum(short int n, int base)
525{
526 QString::setNum(n, base);
527 m_safeString->m_safety = IsNotSafe;
528 return *m_safeString;
529}
530
531SafeString &SafeString::NestedString::setNum(ushort n, int base)
532{
533 QString::setNum(n, base);
534 m_safeString->m_safety = IsNotSafe;
535 return *m_safeString;
536}
537
538SafeString &SafeString::NestedString::setNum(double n, char format, int precision)
539{
540 QString::setNum(n, format, precision);
541 m_safeString->m_safety = IsNotSafe;
542 return *m_safeString;
543}
544
545SafeString &SafeString::NestedString::setNum(float n, char format, int precision)
546{
547 QString::setNum(n, format, precision);
548 m_safeString->m_safety = IsNotSafe;
549 return *m_safeString;
550}
551
552SafeString &SafeString::NestedString::setUnicode(const QChar *unicode, int size)
553{
554 QString::setUnicode(unicode, size);
555 m_safeString->m_safety = IsNotSafe;
556 return *m_safeString;
557}
558
559SafeString &SafeString::NestedString::setUtf16(const ushort *unicode, int size)
560{
561 QString::setUtf16(unicode, size);
562 m_safeString->m_safety = IsNotSafe;
563 return *m_safeString;
564}
565
566SafeString SafeString::NestedString::simplified() const
567{
568 return {QString::simplified(), m_safeString->m_safety};
569}
570
571QStringList SafeString::NestedString::split(const KTextTemplate::SafeString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
572{
573 return QString::split(sep.get(), behavior, cs);
574}
575
576QStringList SafeString::NestedString::split(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
577{
578 return QString::split(sep, behavior, cs);
579}
580
581QStringList SafeString::NestedString::split(const QChar &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
582{
583 return QString::split(sep, behavior, cs);
584}
585
586QStringList SafeString::NestedString::split(const QRegularExpression &rx, Qt::SplitBehavior behavior) const
587{
588 return QString::split(rx, behavior);
589}
590
591SafeString SafeString::NestedString::toLower() const
592{
593 return {QString::toLower(), IsNotSafe};
594}
595
596SafeString SafeString::NestedString::toUpper() const
597{
598 return {QString::toUpper(), IsNotSafe};
599}
600
601SafeString SafeString::NestedString::trimmed() const
602{
603 return {QString::trimmed(), m_safeString->m_safety};
604}
KTextTemplate::SafeString
A QString wrapper class for containing whether a string is safe or needs to be escaped.
Definition safestring.h:81
KTextTemplate::SafeString::operator+=
SafeString & operator+=(const QString &str)
Appends the content of str to this.
Definition safestring.cpp:100
KTextTemplate::SafeString::needsEscape
bool needsEscape() const
Whether the string needs to be escaped.
Definition safestring.cpp:51
KTextTemplate::SafeString::isSafe
bool isSafe() const
Whether the string is safe.
Definition safestring.cpp:61
KTextTemplate::SafeString::Safety
Safety
Possible safety states of a SafeString
Definition safestring.h:86
KTextTemplate::SafeString::IsNotSafe
@ IsNotSafe
The string is not safe.
Definition safestring.h:88
KTextTemplate::SafeString::IsSafe
@ IsSafe
The string is safe and requires no further escaping.
Definition safestring.h:87
KTextTemplate::SafeString::operator+
SafeString operator+(const QString &str)
Returns a concatenation of this with str.
Definition safestring.cpp:88
KTextTemplate::SafeString::SafeString
SafeString()
Constructs an empty SafeString.
Definition safestring.cpp:16
KTextTemplate::SafeString::operator=
SafeString & operator=(const SafeString &str)
Assignment operator.
Definition safestring.cpp:77
KTextTemplate::SafeString::get
const NestedString & get() const
Returns the String held by this SafeString
Definition safestring.h:283
KTextTemplate::SafeString::operator==
bool operator==(const SafeString &other) const
Returns true if the content of other matches the content of this.
Definition safestring.cpp:117
start
Q_SCRIPTABLE Q_NOREPLY void start()
KTextTemplate
The KTextTemplate namespace holds all public KTextTemplate API.
Definition Mainpage.dox:8
QChar::UnicodeVersion
UnicodeVersion
QString::append
QString & append(QChar ch)
QString::chop
void chop(qsizetype n)
QString::fill
QString & fill(QChar ch, qsizetype size)
QString::insert
QString & insert(qsizetype position, QChar ch)
QString::left
QString left(qsizetype n) const const
QString::leftJustified
QString leftJustified(qsizetype width, QChar fill, bool truncate) const const
QString::mid
QString mid(qsizetype position, qsizetype n) const const
QString::normalized
QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const const
QString::prepend
QString & prepend(QChar ch)
QString::push_back
void push_back(QChar ch)
QString::push_front
void push_front(QChar ch)
QString::remove
QString & remove(QChar ch, Qt::CaseSensitivity cs)
QString::repeated
QString repeated(qsizetype times) const const
QString::replace
QString & replace(QChar before, QChar after, Qt::CaseSensitivity cs)
QString::right
QString right(qsizetype n) const const
QString::rightJustified
QString rightJustified(qsizetype width, QChar fill, bool truncate) const const
QString::section
QString section(QChar sep, qsizetype start, qsizetype end, SectionFlags flags) const const
QString::setNum
QString & setNum(double n, char format, int precision)
QString::setUnicode
QString & setUnicode(const QChar *unicode, qsizetype size)
QString::setUtf16
QString & setUtf16(const ushort *unicode, qsizetype size)
QString::simplified
QString simplified() const const
QString::split
QStringList split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const const
QString::toLower
QString toLower() const const
QString::toUpper
QString toUpper() const const
QString::trimmed
QString trimmed() const const
Qt::CaseSensitivity
CaseSensitivity
Qt::SplitBehavior
typedef SplitBehavior
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Sat Dec 21 2024 16:56:17 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.