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 hasTag(const QString &className, const QString &property, const QString &tag);
    static bool hasTag(const QString &className, const QString &property, ConfigObject *obj);
    static ConfigObject *getTag(const QString &className, const QString &property, const QString &tag);
    static QString getTag(const QString &className, const QString &property, ConfigObject *obj);
    static void setTag(const QString &className, const QString &property, const QString &tag, ConfigObject *obj);
 
  protected:
    QString _version;
    QHash<QString, ConfigObject *> _objects;
    QHash<ConfigObject*, QString> _ids;
    static QHash<QString, QHash<QString, ConfigObject *>> _tagObjects;
    static QHash<QString, QHash<ConfigObject *, QString>> _tagNames;
  };
 
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