safestring.h

/*
  This file is part of the Cutelee template system.
 
  Copyright (c) 2009,2010 Stephen Kelly <steveire@gmail.com>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either version
  2.1 of the Licence, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
*/
 
#ifndef CUTELEE_SAFESTRING_H
#define CUTELEE_SAFESTRING_H
 
#include "cutelee_templates_export.h"
 
#include <QtCore/QString>
#include <QtCore/QVariant>
 
namespace Cutelee
{


class CUTELEE_TEMPLATES_EXPORT SafeString
{
public:
  enum Safety {
    IsSafe,   
    IsNotSafe 
  };

  SafeString();

  SafeString(const SafeString &safeString);

  SafeString(const QString &str, bool safe);

  /* implicit */ SafeString(const QString &str,
                            Safety safety
                            = IsNotSafe); // krazy:exclude=explicit

  ~SafeString();
 
#ifndef Q_QDOC
  void setNeedsEscape(bool needsEscape);
#endif

  bool needsEscape() const;

  bool isSafe() const;
 
#ifndef Q_QDOC
  void setSafety(Safety safety);
#endif

  class CUTELEE_TEMPLATES_EXPORT NestedString : public QString
  {
#ifndef Q_QDOC
    friend class SafeString;
    SafeString *m_safeString;
 
  public:
    NestedString(SafeString *safeString);
    NestedString(const QString &content, SafeString *safeString);
 
    SafeString &append(const SafeString &str);
    SafeString &append(const QString &str);
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 2)
    SafeString &append(QStringView reference);
#endif
    SafeString &append(QLatin1String str);
#ifndef QT_NO_CAST_FROM_ASCII
    SafeString &append(const QByteArray &ba)
    {
      QString::append(ba);
      m_safeString->m_safety = IsNotSafe;
      return *m_safeString;
    }
 
    SafeString &append(const char *str)
    {
      QString::append(str);
      m_safeString->m_safety = IsNotSafe;
      return *m_safeString;
    }
#endif
    SafeString &append(const QChar ch);
 
    SafeString &fill(QChar ch, int size = -1);
 
    SafeString &insert(int position, const SafeString &str);
    SafeString &insert(int position, const QString &str);
    SafeString &insert(int position, QLatin1String str);
    SafeString &insert(int position, const QChar *unicode, int size);
    SafeString &insert(int position, QChar ch);
 
    SafeString left(int n) const;
    SafeString leftJustified(int width, QChar fill = QLatin1Char(' '),
                             bool truncate = {}) const;
    SafeString mid(int position, int n = -1) const;
 
    SafeString normalized(NormalizationForm mode) const;
    SafeString normalized(NormalizationForm mode,
                          QChar::UnicodeVersion version) const;
 
    SafeString &prepend(const SafeString &str);
    SafeString &prepend(const QString &str);
    SafeString &prepend(QLatin1String str);
#ifndef QT_NO_CAST_FROM_ASCII
    SafeString &prepend(const QByteArray &ba)
    {
      QString::prepend(ba);
      m_safeString->m_safety = IsNotSafe;
      return *m_safeString;
    }
 
    SafeString &prepend(const char *str)
    {
      QString::prepend(str);
      m_safeString->m_safety = IsNotSafe;
      return *m_safeString;
    }
#endif
    SafeString &prepend(QChar ch);
 
    void push_back(const SafeString &other);
    void push_front(const SafeString &other);
 
    SafeString &remove(int position, int n);
    SafeString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &remove(const SafeString &str,
                       Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &remove(const QString &str,
                       Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &remove(const QRegularExpression &rx);
    SafeString repeated(int times) const;
    SafeString &replace(int position, int n, const SafeString &after);
    SafeString &replace(int position, int n, const QString &after);
    SafeString &replace(int position, int n, const QChar *unicode, int size);
    SafeString &replace(int position, int n, QChar after);
    SafeString &replace(const SafeString &before, const SafeString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(const QString &before, const SafeString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(const SafeString &before, const QString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(const QString &before, const QString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(const QChar *before, int blen, const QChar *after,
                        int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(QChar ch, const SafeString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(QChar ch, const QString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(QChar before, QChar after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(QLatin1String before, QLatin1String after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(QLatin1String before, const SafeString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(QLatin1String before, const QString &after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(const SafeString &before, QLatin1String after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(const QString &before, QLatin1String after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(QChar c, QLatin1String after,
                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
    SafeString &replace(const QRegularExpression &rx, const SafeString &after);
    SafeString &replace(const QRegularExpression &rx, const QString &after);
 
    SafeString right(int n) const;
    SafeString rightJustified(int width, QChar fill = QLatin1Char(' '),
                              bool truncate = {}) const;
 
    SafeString section(QChar sep, int start, int end = -1,
                       SectionFlags flags = SectionDefault) const;
    SafeString section(const SafeString &sep, int start, int end = -1,
                       SectionFlags flags = SectionDefault) const;
    SafeString section(const QString &sep, int start, int end = -1,
                       SectionFlags flags = SectionDefault) const;
    SafeString section(const QRegularExpression &reg, int start, int end = -1,
                       SectionFlags flags = SectionDefault) const;
    SafeString &setNum(int n, int base = 10);
    SafeString &setNum(uint n, int base = 10);
    SafeString &setNum(long n, int base = 10);
    SafeString &setNum(ulong n, int base = 10);
    SafeString &setNum(qlonglong n, int base = 10);
    SafeString &setNum(qulonglong n, int base = 10);
    SafeString &setNum(short n, int base = 10);
    SafeString &setNum(ushort n, int base = 10);
    SafeString &setNum(double n, char format = 'g', int precision = 6);
    SafeString &setNum(float n, char format = 'g', int precision = 6);
    SafeString &setUnicode(const QChar *unicode, int size);
    SafeString &setUtf16(const ushort *unicode, int size);
    SafeString simplified() const;
 
#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
    QStringList split(const SafeString &sep,
                      QString::SplitBehavior behavior = QString::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    QStringList split(const QString &sep,
                      QString::SplitBehavior behavior = QString::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    QStringList split(const QChar &sep, QString::SplitBehavior behavior = QString::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    QStringList split(const QRegularExpression &rx,
                      QString::SplitBehavior behavior = QString::KeepEmptyParts) const;
#else
    QStringList split(const SafeString &sep,
                      Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    QStringList split(const QString &sep,
                      Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    QStringList split(const QChar &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    QStringList split(const QRegularExpression &rx,
                      Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const;
#endif
 
    SafeString toLower() const;
    SafeString toUpper() const;
    SafeString trimmed() const;
 
    void chop(int n);
#endif
  };

  const NestedString &get() const { return m_nestedString; }

  NestedString &get() { return m_nestedString; }

  operator QString() const { return m_nestedString; }

  SafeString &operator=(const SafeString &str);

  SafeString operator+(const QString &str);

  SafeString operator+(const SafeString &str);

  SafeString &operator+=(const QString &str);

  SafeString &operator+=(const SafeString &str);

  bool operator==(const SafeString &other) const;

  bool operator==(const QString &other) const;

  operator QVariant() const { return QVariant::fromValue(*this); }
 
private:
#ifndef Q_QDOC
  NestedString m_nestedString;
#endif
  Safety m_safety;
  bool m_needsescape;
};
}
 
Q_DECLARE_METATYPE(Cutelee::SafeString)
 
#endif