configobject.hh

#ifndef CONFIGOBJECT_HH
#define CONFIGOBJECT_HH
 
#include <QObject>
#include <QString>
#include <QHash>
#include <QVector>
#include <QMetaProperty>
 
#include <yaml-cpp/yaml.h>
 
#include "errorstack.hh"
 
// Forward declaration
class Config;
class ConfigObject;
class ConfigExtension;

template <class T>
bool propIsInstance(const QMetaProperty &prop) {
  if (QMetaType::UnknownType == prop.typeId())
    return false;
  QMetaType type = prop.metaType();
  if (! (QMetaType::PointerToQObject & type.flags()))
    return false;
  return type.metaObject()->inherits(&T::staticMetaObject);
}
 

class ConfigItem : public QObject
{
  Q_OBJECT
 
public:
  class Context
  {
  public:
    Context();
    virtual ~Context();

    const QString &version() const;
    void setVersion(const QString &ver);

    virtual bool contains(ConfigObject *obj) const;
    virtual bool contains(const QString &id) const;

    virtual QString getId(ConfigObject *obj) const;
    virtual ConfigObject *getObj(const QString &id) const;

    virtual bool add(const QString &id, ConfigObject *);

    static bool tagIsSet(const QString &className, const QString &property, const QString &tag);
    static bool hasTag(const QString &className, const QString &property, QVariant value);
    static QVariant tagGetValue(const QString &className, const QString &property, const QString &tag);
    static QString getTag(const QString &className, const QString &property, QVariant value);
    static void setTag(const QString &className, const QString &property, const QString &tag, QVariant value);
 
  protected:
    QString _version;
    QHash<QString, ConfigObject *> _objects;
    QHash<ConfigObject*, QString> _ids;
    static QHash<QString, QList<QPair<QString, QVariant>>> _tags;
  };
 
protected:
  explicit ConfigItem(QObject *parent = nullptr);
 
public:
  virtual bool copy(const ConfigItem &other);

  virtual ConfigItem *clone() const = 0;

  virtual int compare(const ConfigItem &other) const;
 
public:
  virtual bool label(Context &context, const ErrorStack &err=ErrorStack());
  virtual YAML::Node serialize(const Context &context, const ErrorStack &err=ErrorStack());

  virtual ConfigItem *allocateChild(QMetaProperty &prop, const YAML::Node &node,
                                    const Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool parse(const YAML::Node &node, Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool link(const YAML::Node &node, const Context &ctx, const ErrorStack &err=ErrorStack());

  virtual void clear();

  virtual const Config *config() const;
  virtual void findItemsOfTypes(const QStringList &typeNames, QSet<ConfigItem*> &items) const;

  template <class Object>
  bool is() const {
    return nullptr != qobject_cast<const Object*>(this);
  }

  template <class Object>
  const Object *as() const {
    return qobject_cast<const Object*>(this);
  }

  template <class Object>
  Object *as() {
    return qobject_cast<Object *>(this);
  }

  bool hasDescription() const;
  bool hasLongDescription() const;
  bool hasDescription(const QMetaProperty &prop) const;
  bool hasLongDescription(const QMetaProperty &prop) const;
  QString description() const;
  QString longDescription() const;
  QString description(const QMetaProperty &prop) const;
  QString longDescription(const QMetaProperty &prop) const;
 
protected:
  virtual bool populate(YAML::Node &node, const Context &context, const ErrorStack &err=ErrorStack());
 
signals:
  void modified(ConfigItem *obj);
  void beginClear();
  void endClear();
};
 

class ConfigObject: public ConfigItem
{
  Q_OBJECT

  Q_PROPERTY(QString name READ name WRITE setName)
 
  
  Q_CLASSINFO("IdPrefix", "obj")
 
protected:
  ConfigObject(QObject *parent = nullptr);

  ConfigObject(const QString &name, QObject *parent = nullptr);
 
public:
  virtual const QString &name() const;
  virtual void setName(const QString &name);
 
public:
  QString idPrefix() const;
  bool label(Context &context, const ErrorStack &err=ErrorStack());
  bool parse(const YAML::Node &node, Context &ctx, const ErrorStack &err=ErrorStack());
 
protected:
  virtual bool populate(YAML::Node &node, const Context &context, const ErrorStack &err=ErrorStack());

  static QString findIdPrefix(const QMetaObject* meta);
 
protected:
  QString _name;
};
 

class ConfigExtension : public ConfigItem
{
  Q_OBJECT
 
protected:
  explicit ConfigExtension(QObject *parent=nullptr);
};
 

class AbstractConfigObjectList: public QObject
{
  Q_OBJECT
 
protected:
  explicit AbstractConfigObjectList(const QMetaObject &elementTypes=ConfigObject::staticMetaObject, QObject *parent = nullptr);
  AbstractConfigObjectList(const std::initializer_list<QMetaObject> &elementTypes, QObject *parent=nullptr);
 
public:
  virtual bool copy(const AbstractConfigObjectList &other);

  virtual bool label(ConfigItem::Context &context, const ErrorStack &err=ErrorStack()) = 0;
  virtual YAML::Node serialize(const ConfigItem::Context &context, const ErrorStack &err=ErrorStack()) = 0;

  virtual int count() const;
  virtual int indexOf(ConfigObject *obj) const;
  virtual void clear();

  virtual const Config *config() const;
  virtual void findItemsOfTypes(const QStringList &typeNames, QSet<ConfigItem*> &items) const;
  virtual QList<ConfigObject *> findItemsByName(const QString name) const;

  virtual bool has(ConfigObject *obj) const;
  virtual ConfigObject *get(int idx) const;
  virtual int add(ConfigObject *obj, int row=-1, bool unique=true);
  virtual int replace(ConfigObject *obj, int row, bool unique=true);
  virtual bool take(ConfigObject *obj);
  virtual bool del(ConfigObject *obj);

  virtual bool moveUp(int idx);
  virtual bool moveUp(int first, int last);
  virtual bool moveDown(int idx);
  virtual bool moveDown(int first, int last);
  virtual bool move(int source, int count, int destination);

  const QList<QMetaObject> &elementTypes() const;
  QStringList classNames() const;
 
signals:
  void elementAdded(int idx);
  void elementModified(int idx);
  void elementRemoved(int idx);
 
private slots:
  void onElementModified(ConfigItem *obj);
  void onElementDeleted(QObject *obj);
 
protected:
  QList<QMetaObject> _elementTypes;
  QVector<ConfigObject *> _items;
};
 

class ConfigObjectList: public AbstractConfigObjectList
{
  Q_OBJECT
 
protected:
  explicit ConfigObjectList(const QMetaObject &elementTypes=ConfigItem::staticMetaObject, QObject *parent = nullptr);
  ConfigObjectList(const std::initializer_list<QMetaObject> &elementTypes, QObject *parent=nullptr);
 
public:
  int add(ConfigObject *obj, int row=-1, bool unique=true);
  bool take(ConfigObject *obj);
  bool del(ConfigObject *obj);
  void clear();
  bool copy(const AbstractConfigObjectList &other);

  virtual int compare(const ConfigObjectList &other) const;

  virtual ConfigItem *allocateChild(const YAML::Node &node, ConfigItem::Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool parse(const YAML::Node &node, ConfigItem::Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool link(const YAML::Node &node, const ConfigItem::Context &ctx, const ErrorStack &err=ErrorStack());
 
  bool label(ConfigItem::Context &context, const ErrorStack &err=ErrorStack());
  YAML::Node serialize(const ConfigItem::Context &context, const ErrorStack &err=ErrorStack());
};
 

class ConfigObjectRefList: public AbstractConfigObjectList
{
  Q_OBJECT
 
protected:
  explicit ConfigObjectRefList(const QMetaObject &elementTypes=ConfigObject::staticMetaObject, QObject *parent = nullptr);
  ConfigObjectRefList(const std::initializer_list<QMetaObject> &elementTypes, QObject *parent=nullptr);
 
public:
  bool label(ConfigItem::Context &context, const ErrorStack &err=ErrorStack());
  YAML::Node serialize(const ConfigItem::Context &context, const ErrorStack &err=ErrorStack());

  virtual int compare(const ConfigObjectRefList &other) const;
};
 
 
#endif // CONFIGOBJECT_HH