File indexing completed on 2024-11-10 04:40:47

 /*
     SPDX-FileCopyrightText: 2017 Daniel Vrátil <dvratil@kde.og>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QList>
 #include <QMultiMap>
 
 class Node
 {
 public:
     enum NodeType {
         Document,
         Class,
         Ctor,
         Enum,
         EnumValue,
         Property,
     };
 
     Node(NodeType type, Node *parent);
     Node(const Node &) = delete;
     Node(Node &&) = delete;
     virtual ~Node();
 
     Node &operator=(const Node &) = delete;
     Node &operator=(Node &&) = delete;
 
     NodeType type() const;
     Node *parent() const;
 
     void appendNode(Node *child);
 
     const QList<Node const *> &children() const;
 
 protected:
     Node *mParent;
     QList<Node const *> mChildren;
     NodeType mType;
 };
 
 class DocumentNode : public Node
 {
 public:
     DocumentNode(int version);
 
     int version() const;
 
 private:
     int mVersion;
 };
 
 class PropertyNode;
 class ClassNode : public Node
 {
 public:
     enum ClassType {
         Invalid,
         Class,
         Command,
         Response,
         Notification,
     };
 
     ClassNode(const QString &name, ClassType type, DocumentNode *parent);
     QString name() const;
     ClassType classType() const;
     QString className() const;
     QString parentClassName() const;
     QList<PropertyNode const *> properties() const;
 
     static ClassType elementNameToType(QStringView name);
 
 private:
     QString mName;
     ClassType mClassType;
 };
 
 class CtorNode : public Node
 {
 public:
     struct Argument {
         QString name;
         QString type;
         QString defaultValue;
 
         QString mVariableName() const
         {
             return QStringLiteral("m") + name[0].toUpper() + QStringView(name).mid(1);
         }
     };
 
     CtorNode(const QList<Argument> &args, ClassNode *parent);
     ~CtorNode() override;
 
     QList<Argument> arguments() const;
     void setArgumentType(const QString &name, const QString &type);
 
 private:
     QList<Argument> mArgs;
 };
 
 class EnumNode : public Node
 {
 public:
     enum EnumType {
         TypeInvalid,
         TypeEnum,
         TypeFlag,
     };
 
     EnumNode(const QString &name, EnumType type, ClassNode *parent);
 
     QString name() const;
     EnumType enumType() const;
     static EnumType elementNameToType(QStringView name);
 
     QString flagsName() const;
 
 private:
     QString mName;
     EnumType mEnumType;
 };
 
 class EnumValueNode : public Node
 {
 public:
     EnumValueNode(const QString &name, EnumNode *parent);
 
     QString name() const;
     void setValue(const QString &value);
     QString value() const;
 
 private:
     QString mName;
     QString mValue;
 };
 
 class PropertyNode : public Node
 {
 public:
     struct Setter {
         QString name;
         QString type;
         QString append;
         QString remove;
     };
 
     PropertyNode(const QString &name, const QString &type, ClassNode *parent);
     ~PropertyNode() override;
 
     QString type() const;
     QString name() const;
 
     void setDefaultValue(const QString &defaultValue);
     QString defaultValue() const;
 
     bool readOnly() const;
     void setReadOnly(bool readOnly);
 
     bool asReference() const;
     void setAsReference(bool asReference);
 
     bool isPointer() const;
     bool isEnum() const;
 
     QMultiMap<QString, QString> dependencies() const;
     void addDependency(const QString &enumVar, const QString &enumValue);
 
     Setter *setter() const;
     void setSetter(Setter *setter);
 
     QString mVariableName() const;
     QString setterName() const;
 
 private:
     QString mName;
     QString mType;
     QString mDefaultValue;
     QMultiMap<QString, QString> mDepends;
     Setter *mSetter;
     bool mReadOnly;
     bool mAsReference;
 };