File indexing completed on 2024-05-05 05:54:13

 /*
     This file is part of Konsole, a terminal emulator for KDE.
 
     SPDX-FileCopyrightText: 2018 Mariusz Glebocki <mglb@arccos-1.net>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef TEMPLATE_H
 #define TEMPLATE_H
 
 #include <QMap>
 #include <QString>
 #include <QVector>
 
 // QVariant doesn't offer modification in place. Var does.
 class Var
 {
 public:
     using Number = qint64;
     using String = QString;
     using Map = QMap<String, Var>;
     using Vector = QVector<Var>;
 
     enum class DataType {
         Invalid,
         Number,
         String,
         Vector,
         Map,
     };
 
     const QString dataTypeAsString() const
     {
         switch (dataType()) {
         case DataType::Invalid:
             return QStringLiteral("Invalid");
         case DataType::Number:
             return QStringLiteral("Number");
         case DataType::String:
             return QStringLiteral("String");
         case DataType::Vector:
             return QStringLiteral("Vector");
         case DataType::Map:
             return QStringLiteral("Map");
         default:
             return QStringLiteral("Unknown?");
         }
     }
 
     Var()
         : num(0)
         , _dataType(DataType::Invalid)
     {
     }
     Var(const Var &other)
     {
         *this = other;
     }
 
     Var(const Number &newNum)
         : _dataType(DataType::Number)
     {
         new (&num) auto(newNum);
     }
     Var(const String &newStr)
         : _dataType(DataType::String)
     {
         new (&str) auto(newStr);
     }
     Var(const Vector &newVec)
         : _dataType(DataType::Vector)
     {
         new (&vec) auto(newVec);
     }
     Var(const Map &newMap)
         : _dataType(DataType::Map)
     {
         new (&map) auto(newMap);
     }
 
     // Allow initialization without type name
     Var(const char *newStr)
         : _dataType(DataType::String)
     {
         new (&str) String(QString::fromUtf8(newStr));
     }
     Var(std::initializer_list<Var> newVec)
         : _dataType(DataType::Vector)
     {
         new (&vec) Vector(newVec);
     }
 
     ~Var()
     {
         switch (dataType()) {
         case DataType::String:
             str.~String();
             break;
         case DataType::Vector:
             vec.~Vector();
             break;
         case DataType::Map:
             map.~Map();
             break;
         default:
             break;
         }
     }
 
     Var &operator=(const Var &other)
     {
         _dataType = other.dataType();
         switch (other.dataType()) {
         case DataType::Number:
             new (&num) auto(other.num);
             break;
         case DataType::String:
             new (&str) auto(other.str);
             break;
         case DataType::Vector:
             new (&vec) auto(other.vec);
             break;
         case DataType::Map:
             new (&map) auto(other.map);
             break;
         default:
             break;
         }
         return *this;
     }
 
     Var &operator[](unsigned index)
     {
         Q_ASSERT(_dataType == DataType::Vector);
         return vec.data()[index];
     }
     const Var &operator[](unsigned index) const
     {
         Q_ASSERT(_dataType == DataType::Vector);
         return vec.constData()[index];
     }
     Var &operator[](const String &key)
     {
         Q_ASSERT(_dataType == DataType::Map);
         return map[key];
     }
     const Var &operator[](const String &key) const
     {
         Q_ASSERT(_dataType == DataType::Map);
         return *map.find(key);
     }
 
     DataType dataType() const
     {
         return _dataType;
     }
 
     union {
         Number num;
         String str;
         Vector vec;
         Map map;
     };
 
 private:
     DataType _dataType;
 };
 
 class Template
 {
 public:
     Template(const QString &text);
     void parse();
     QString generate(const Var &data);
 
     struct Element {
         Element(const Element *parent = nullptr, const QString &name = QString())
             : outer()
             , inner()
             , name(name)
             , fmt()
             , line(0)
             , column(0)
             , isComment(false)
             , children()
             , parent(parent)
         {
         }
 
         Element(const Element &other)
             : outer(other.outer)
             , inner(other.inner)
             , name(other.name)
             , fmt(other.fmt)
             , line(other.line)
             , column(other.column)
             , isComment(other.isComment)
             , parent(other.parent)
         {
             for (const auto &child : other.children) {
                 children.append(child);
             }
         }
 
         const QString findFmt(Var::DataType type) const;
         QString path() const;
         bool isCommand() const
         {
             return name.startsWith(QLatin1Char('!'));
         }
         bool hasName() const
         {
             return !isCommand() && !name.isEmpty();
         }
 
         static const QString defaultFmt(Var::DataType type);
         static bool isValidFmt(const QString &fmt, Var::DataType type);
 
         QStringRef outer;
         QStringRef inner;
         QString name;
         QString fmt;
         uint line;
         uint column;
         bool isComment;
         QList<Element> children;
         const Element *parent;
     };
 
 private:
     void executeCommand(Element &element, const Element &childStub, const QStringList &argv);
     void parseRecursively(Element &element);
     int generateRecursively(QString &result, const Element &element, const Var &data, int consumed = 0);
 
     QString _text; // FIXME: make it pointer (?)
     Element _root; // FIXME: make it pointer
 };
 
 #endif