File indexing completed on 2025-02-09 04:28:40

 /*
   This file is part of the KTextTemplate library
 
   SPDX-FileCopyrightText: 2009, 2010 Stephen Kelly <steveire@gmail.com>
 
   SPDX-License-Identifier: LGPL-2.1-or-later
 
 */
 
 #include "safestring.h"
 
 #include <QStringList>
 
 using namespace KTextTemplate;
 
 SafeString::SafeString()
     : m_nestedString(this)
     , m_safety(IsNotSafe)
     , m_needsescape(false)
 {
 }
 
 SafeString::SafeString(const KTextTemplate::SafeString &safeString)
     : m_nestedString(safeString.get(), this)
     , m_safety(safeString.m_safety)
     , m_needsescape(safeString.m_needsescape)
 {
 }
 
 SafeString::SafeString(const QString &str, bool safe)
     : m_nestedString(str, this)
     , m_safety(safe ? IsSafe : IsNotSafe)
     , m_needsescape(false)
 {
 }
 
 SafeString::SafeString(const QString &str, Safety safety)
     : m_nestedString(str, this)
     , m_safety(safety)
     , m_needsescape(false)
 {
 }
 
 SafeString::~SafeString() = default;
 
 void SafeString::setNeedsEscape(bool needsEscape)
 {
     m_needsescape = needsEscape;
 }
 
 bool SafeString::needsEscape() const
 {
     return m_needsescape;
 }
 
 void SafeString::setSafety(KTextTemplate::SafeString::Safety safety)
 {
     m_safety = safety;
 }
 
 bool SafeString::isSafe() const
 {
     return m_safety == IsSafe;
 }
 
 SafeString::NestedString::NestedString(SafeString *safeString)
     : m_safeString(safeString)
 {
 }
 
 SafeString::NestedString::NestedString(const QString &content, SafeString *safeString)
     : QString(content)
     , m_safeString(safeString)
 {
 }
 
 SafeString &SafeString::operator=(const SafeString &str)
 {
     if (&str == this)
         return *this;
     m_nestedString = str.m_nestedString;
     m_nestedString.m_safeString = this;
     m_safety = str.m_safety;
     m_needsescape = str.m_needsescape;
     return *this;
 }
 
 SafeString SafeString::operator+(const QString &str)
 {
     return {static_cast<QString>(m_nestedString) + str, IsNotSafe};
 }
 
 SafeString SafeString::operator+(const SafeString &str)
 {
     if (!str.isSafe())
         return {static_cast<QString>(m_nestedString) + static_cast<QString>(str.get()), IsNotSafe};
     return {static_cast<QString>(m_nestedString) + static_cast<QString>(str.get()), m_safety};
 }
 
 SafeString &SafeString::operator+=(const QString &str)
 {
     m_safety = IsNotSafe;
 
     m_nestedString += str;
     return *this;
 }
 
 SafeString &SafeString::operator+=(const SafeString &str)
 {
     if (!str.isSafe())
         m_safety = IsNotSafe;
 
     m_nestedString += str.get();
     return *this;
 }
 
 bool SafeString::operator==(const KTextTemplate::SafeString &other) const
 {
     // Don't compare safety or account for future escaping here.
     // See TestBuiltins testEscaping
     return m_nestedString == other.get();
 }
 
 bool SafeString::operator==(const QString &other) const
 {
     return m_nestedString == other;
 }
 
 SafeString &SafeString::NestedString::append(const SafeString &str)
 {
     QString::append(str.get());
     if (!str.isSafe())
         m_safeString->m_safety = IsNotSafe;
 
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::append(const QString &str)
 {
     QString::append(str);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::append(const QLatin1String &str)
 {
     QString::append(str);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::append(const QChar ch)
 {
     QString::append(ch);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 void SafeString::NestedString::chop(int n)
 {
     QString::chop(n);
     m_safeString->m_safety = IsNotSafe;
 }
 
 SafeString &SafeString::NestedString::fill(QChar ch, int size)
 {
     QString::fill(ch, size);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::insert(int position, const KTextTemplate::SafeString &str)
 {
     QString::insert(position, str.get());
     if (!str.isSafe())
         m_safeString->m_safety = IsNotSafe;
 
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::insert(int position, const QString &str)
 {
     QString::insert(position, str);
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::insert(int position, const QLatin1String &str)
 {
     QString::insert(position, str);
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::insert(int position, const QChar *unicode, int size)
 {
     QString::insert(position, unicode, size);
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::insert(int position, QChar ch)
 {
     QString::insert(position, ch);
     return *m_safeString;
 }
 
 SafeString SafeString::NestedString::left(int n) const
 {
     return {QString::left(n), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::leftJustified(int width, QChar fill, bool truncate) const
 {
     return {QString::leftJustified(width, fill, truncate), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::mid(int position, int n) const
 {
     return {QString::mid(position, n), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::normalized(QString::NormalizationForm mode) const
 {
     return {QString::normalized(mode), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version) const
 {
     return {QString::normalized(mode, version), m_safeString->m_safety};
 }
 
 SafeString &SafeString::NestedString::prepend(const KTextTemplate::SafeString &str)
 {
     QString::prepend(str.get());
     if (!str.isSafe())
         m_safeString->m_safety = IsNotSafe;
 
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::prepend(const QString &str)
 {
     QString::prepend(str);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::prepend(const QLatin1String &str)
 {
     QString::prepend(str);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::prepend(QChar ch)
 {
     QString::prepend(ch);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 void SafeString::NestedString::push_back(const KTextTemplate::SafeString &other)
 {
     QString::push_back(other.get());
     m_safeString->m_safety = other.m_safety;
 }
 
 void SafeString::NestedString::push_front(const KTextTemplate::SafeString &other)
 {
     QString::push_front(other.get());
     m_safeString->m_safety = other.m_safety;
 }
 
 SafeString &SafeString::NestedString::remove(int position, int n)
 {
     QString::remove(position, n);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::remove(QChar ch, Qt::CaseSensitivity cs)
 {
     QString::remove(ch, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::remove(const KTextTemplate::SafeString &str, Qt::CaseSensitivity cs)
 {
     QString::remove(str, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::remove(const QString &str, Qt::CaseSensitivity cs)
 {
     QString::remove(str, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::remove(const QRegularExpression &rx)
 {
     QString::remove(rx);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString SafeString::NestedString::repeated(int times) const
 {
     return {QString::repeated(times), m_safeString->m_safety};
 }
 
 SafeString &SafeString::NestedString::replace(int position, int n, const KTextTemplate::SafeString &after)
 {
     QString::replace(position, n, after.get());
     m_safeString->m_safety = after.m_safety;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(int position, int n, const QString &after)
 {
     QString::replace(position, n, after);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(int position, int n, const QChar *unicode, int size)
 {
     QString::replace(position, n, unicode, size);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(int position, int n, QChar after)
 {
     QString::replace(position, n, after);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const KTextTemplate::SafeString &before, const KTextTemplate::SafeString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before.get(), after.get(), cs);
     m_safeString->m_safety = after.m_safety;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QString &before, const KTextTemplate::SafeString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before, after.get(), cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const KTextTemplate::SafeString &before, const QString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before.get(), after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before, after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs)
 {
     QString::replace(before, blen, after, alen, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(QChar ch, const SafeString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(ch, after.get(), cs);
     m_safeString->m_safety = after.m_safety;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(QChar ch, const QString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(ch, after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(QChar before, QChar after, Qt::CaseSensitivity cs)
 {
     QString::replace(before, after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before, after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QLatin1String &before, const KTextTemplate::SafeString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before, after.get(), cs);
     m_safeString->m_safety = after.m_safety;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before, after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const KTextTemplate::SafeString &before, const QLatin1String &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before.get(), after, cs);
     m_safeString->m_safety = before.m_safety;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs)
 {
     QString::replace(before, after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs)
 {
     QString::replace(c, after, cs);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QRegularExpression &rx, const KTextTemplate::SafeString &after)
 {
     QString::replace(rx, after.get());
     m_safeString->m_safety = after.m_safety;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::replace(const QRegularExpression &rx, const QString &after)
 {
     QString::replace(rx, after);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString SafeString::NestedString::right(int n) const
 {
     return {QString::right(n), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::rightJustified(int width, QChar fill, bool truncate) const
 {
     return {QString::rightJustified(width, fill, truncate), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::section(const QRegularExpression &reg, int start, int end, QString::SectionFlags flags) const
 {
     return {QString::section(reg, start, end, flags), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::section(QChar sep, int start, int end, QString::SectionFlags flags) const
 {
     return {QString::section(sep, start, end, flags), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::section(const KTextTemplate::SafeString &sep, int start, int end, QString::SectionFlags flags) const
 {
     return {QString::section(sep, start, end, flags), m_safeString->m_safety};
 }
 
 SafeString SafeString::NestedString::section(const QString &sep, int start, int end, QString::SectionFlags flags) const
 {
     return {QString::section(sep, start, end, flags), m_safeString->m_safety};
 }
 
 SafeString &SafeString::NestedString::setNum(int n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(uint n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(long int n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(ulong n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(qlonglong n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(qulonglong n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(short int n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(ushort n, int base)
 {
     QString::setNum(n, base);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(double n, char format, int precision)
 {
     QString::setNum(n, format, precision);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setNum(float n, char format, int precision)
 {
     QString::setNum(n, format, precision);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setUnicode(const QChar *unicode, int size)
 {
     QString::setUnicode(unicode, size);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString &SafeString::NestedString::setUtf16(const ushort *unicode, int size)
 {
     QString::setUtf16(unicode, size);
     m_safeString->m_safety = IsNotSafe;
     return *m_safeString;
 }
 
 SafeString SafeString::NestedString::simplified() const
 {
     return {QString::simplified(), m_safeString->m_safety};
 }
 
 QStringList SafeString::NestedString::split(const KTextTemplate::SafeString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
 {
     return QString::split(sep.get(), behavior, cs);
 }
 
 QStringList SafeString::NestedString::split(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
 {
     return QString::split(sep, behavior, cs);
 }
 
 QStringList SafeString::NestedString::split(const QChar &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
 {
     return QString::split(sep, behavior, cs);
 }
 
 QStringList SafeString::NestedString::split(const QRegularExpression &rx, Qt::SplitBehavior behavior) const
 {
     return QString::split(rx, behavior);
 }
 
 SafeString SafeString::NestedString::toLower() const
 {
     return {QString::toLower(), IsNotSafe};
 }
 
 SafeString SafeString::NestedString::toUpper() const
 {
     return {QString::toUpper(), IsNotSafe};
 }
 
 SafeString SafeString::NestedString::trimmed() const
 {
     return {QString::trimmed(), m_safeString->m_safety};
 }