Add Calamares::PluginFactory to allow multiple instances of a Qt Plugin.

src/libcalamaresui/utils/PluginFactory.cpp

+/* === This file is part of Calamares - <http://github.com/calamares> ===
+ *
+ *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
+ *
+ *   Based on KPluginFactory from KCoreAddons, KDE project
+ *   Copyright 2007, Matthias Kretz <kretz@kde.org>
+ *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
+ *
+ *   Calamares is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   Calamares 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 General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Calamares. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "PluginFactory.h"
+#include "PluginFactory_p.h"
+
+#include <QObjectCleanupHandler>
+#include <QDebug>
+
+Q_GLOBAL_STATIC(QObjectCleanupHandler, factorycleanup)
+
+extern int kLibraryDebugArea();
+
+namespace Calamares
+{
+
+PluginFactory::PluginFactory()
+    : d_ptr(new PluginFactoryPrivate)
+{
+    Q_D(PluginFactory);
+    d->q_ptr = this;
+
+    factorycleanup()->add(this);
+}
+
+PluginFactory::PluginFactory(PluginFactoryPrivate &d)
+    : d_ptr(&d)
+{
+    factorycleanup()->add(this);
+}
+
+PluginFactory::~PluginFactory()
+{
+    delete d_ptr;
+}
+
+void PluginFactory::doRegisterPlugin(const QString &keyword, const QMetaObject *metaObject, CreateInstanceFunction instanceFunction)
+{
+    Q_D(PluginFactory);
+
+    Q_ASSERT(metaObject);
+
+    // we allow different interfaces to be registered without keyword
+    if (!keyword.isEmpty()) {
+        if (d->createInstanceHash.contains(keyword)) {
+            qWarning() << "A plugin with the keyword" << keyword << "was already registered. A keyword must be unique!";
+        }
+        d->createInstanceHash.insert(keyword, PluginFactoryPrivate::Plugin(metaObject, instanceFunction));
+    } else {
+        QList<PluginFactoryPrivate::Plugin> clashes(d->createInstanceHash.values(keyword));
+        const QMetaObject *superClass = metaObject->superClass();
+        if (superClass) {
+            foreach (const PluginFactoryPrivate::Plugin &plugin, clashes) {
+                for (const QMetaObject *otherSuper = plugin.first->superClass(); otherSuper;
+                        otherSuper = otherSuper->superClass()) {
+                    if (superClass == otherSuper) {
+                        qWarning() << "Two plugins with the same interface(" << superClass->className() << ") were registered. Use keywords to identify the plugins.";
+                    }
+                }
+            }
+        }
+        foreach (const PluginFactoryPrivate::Plugin &plugin, clashes) {
+            superClass = plugin.first->superClass();
+            if (superClass) {
+                for (const QMetaObject *otherSuper = metaObject->superClass(); otherSuper;
+                        otherSuper = otherSuper->superClass()) {
+                    if (superClass == otherSuper) {
+                        qWarning() << "Two plugins with the same interface(" << superClass->className() << ") were registered. Use keywords to identify the plugins.";
+                    }
+                }
+            }
+        }
+        d->createInstanceHash.insertMulti(keyword, PluginFactoryPrivate::Plugin(metaObject, instanceFunction));
+    }
+}
+
+QObject *PluginFactory::create(const char *iface, QWidget *parentWidget, QObject *parent, const QString &keyword)
+{
+    Q_D(PluginFactory);
+
+    QObject *obj = 0;
+
+    const QList<PluginFactoryPrivate::Plugin> candidates(d->createInstanceHash.values(keyword));
+    // for !keyword.isEmpty() candidates.count() is 0 or 1
+
+    foreach (const PluginFactoryPrivate::Plugin &plugin, candidates) {
+        for (const QMetaObject *current = plugin.first; current; current = current->superClass()) {
+            if (0 == qstrcmp(iface, current->className())) {
+                if (obj) {
+                    qWarning() << "ambiguous interface requested from a DSO containing more than one plugin";
+                }
+                obj = plugin.second(parentWidget, parent);
+                break;
+            }
+        }
+    }
+
+    if (obj) {
+        emit objectCreated(obj);
+    }
+    return obj;
+}
+
+}

src/libcalamaresui/utils/PluginFactory.h

+/* === This file is part of Calamares - <http://github.com/calamares> ===
+ *
+ *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
+ *
+ *   Based on KPluginFactory from KCoreAddons, KDE project
+ *   Copyright 2007, Matthias Kretz <kretz@kde.org>
+ *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
+ *
+ *   Calamares is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   Calamares 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 General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Calamares. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CALAMARESPLUGINFACTORY_H
+#define CALAMARESPLUGINFACTORY_H
+
+#include "UiDllMacro.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QVariant>
+#include <QtCore/QStringList>
+
+namespace Calamares
+{
+class PluginFactoryPrivate;
+}
+
+#define CalamaresPluginFactory_iid "io.calamares.PluginFactory"
+
+#define CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY_SKEL(name, baseFactory, ...) \
+    class name : public Calamares::PluginFactory \
+    { \
+        Q_OBJECT \
+        Q_INTERFACES(Calamares::PluginFactory) \
+        __VA_ARGS__ \
+    public: \
+        explicit name(); \
+        ~name(); \
+    private: \
+        void init(); \
+    };
+
+#define CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, baseFactory) \
+    CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY_SKEL(name, baseFactory, Q_PLUGIN_METADATA(IID CalamaresPluginFactory_iid))
+
+#define CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations) \
+    name::name() \
+    { \
+        pluginRegistrations \
+    } \
+    name::~name() {}
+
+#define CALAMARES_PLUGIN_FACTORY_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations) \
+    CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, baseFactory) \
+    CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, baseFactory, pluginRegistrations)
+
+#define CALAMARES_PLUGIN_FACTORY_DECLARATION(name) CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, Calamares::PluginFactory)
+#define CALAMARES_PLUGIN_FACTORY_DEFINITION(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
+
+/**
+ * \relates PluginFactory
+ *
+ * Create a PluginFactory subclass and export it as the root plugin object.
+ *
+ * \param name The name of the PluginFactory derived class.
+ *
+ * \param pluginRegistrations Code to be inserted into the constructor of the
+ * class. Usually a series of registerPlugin() calls.
+ *
+ * Example:
+ * \code
+ * #include <PluginFactory.h>
+ * #include <plugininterface.h>
+ *
+ * class MyPlugin : public PluginInterface
+ * {
+ * public:
+ *     MyPlugin(QObject *parent, const QVariantList &args)
+ *         : PluginInterface(parent)
+ *     {}
+ * };
+ *
+ * CALAMARES_PLUGIN_FACTORY(MyPluginFactory,
+ *                  registerPlugin<MyPlugin>();
+ *                 )
+ *
+ * #include <myplugin.moc>
+ * \endcode
+ *
+ * \see CALAMARES_PLUGIN_FACTORY_DECLARATION
+ * \see CALAMARES_PLUGIN_FACTORY_DEFINITION
+ */
+#define CALAMARES_PLUGIN_FACTORY(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
+
+/**
+ * \relates PluginFactory
+ *
+ * CALAMARES_PLUGIN_FACTORY_DECLARATION declares the PluginFactory subclass. This macro
+ * can be used in a header file.
+ *
+ * \param name The name of the PluginFactory derived class.
+ *
+ * \see CALAMARES_PLUGIN_FACTORY
+ * \see CALAMARES_PLUGIN_FACTORY_DEFINITION
+ */
+#define CALAMARES_PLUGIN_FACTORY_DECLARATION(name) CALAMARES_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY(name, Calamares::PluginFactory)
+
+/**
+ * \relates PluginFactory
+ * CALAMARES_PLUGIN_FACTORY_DEFINITION defines the PluginFactory subclass. This macro
+ * can <b>not</b> be used in a header file.
+ *
+ * \param name The name of the PluginFactory derived class.
+ *
+ * \param pluginRegistrations Code to be inserted into the constructor of the
+ * class. Usually a series of registerPlugin() calls.
+ *
+ * \see CALAMARES_PLUGIN_FACTORY
+ * \see CALAMARES_PLUGIN_FACTORY_DECLARATION
+ */
+#define CALAMARES_PLUGIN_FACTORY_DEFINITION(name, pluginRegistrations) CALAMARES_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY(name, Calamares::PluginFactory, pluginRegistrations)
+
+namespace Calamares
+{
+
+/**
+ * \class PluginFactory PluginFactory.h <PluginFactory.h>
+ *
+ * PluginFactory provides a convenient way to provide factory-style plugins.
+ * Qt plugins provide a singleton object, but a common pattern is for plugins
+ * to generate as many objects of a particular type as the application requires.
+ * By using PluginFactory, you can avoid implementing the factory pattern
+ * yourself.
+ *
+ * PluginFactory also allows plugins to provide multiple different object
+ * types, indexed by keywords.
+ *
+ * The objects created by PluginFactory must inherit QObject, and must have a
+ * standard constructor pattern:
+ * \li if the object is a KPart::Part, it must be of the form
+ * \code
+ * T(QWidget *parentWidget, QObject *parent, const QVariantList &args)
+ * \endcode
+ * \li if it is a QWidget, it must be of the form
+ * \code
+ * T(QWidget *parent, const QVariantList &args)
+ * \endcode
+ * \li otherwise it must be of the form
+ * \code
+ * T(QObject *parent, const QVariantList &args)
+ * \endcode
+ *
+ * You should typically use either CALAMARES_PLUGIN_FACTORY() or
+ * CALAMARES_PLUGIN_FACTORY_WITH_JSON() in your plugin code to create the factory.  The
+ * typical pattern is
+ *
+ * \code
+ * #include <PluginFactory.h>
+ * #include <plugininterface.h>
+ *
+ * class MyPlugin : public PluginInterface
+ * {
+ * public:
+ *     MyPlugin(QObject *parent, const QVariantList &args)
+ *         : PluginInterface(parent)
+ *     {}
+ * };
+ *
+ * CALAMARES_PLUGIN_FACTORY(MyPluginFactory,
+ *                  registerPlugin<MyPlugin>();
+ *                 )
+ * #include <myplugin.moc>
+ * \endcode
+ *
+ * If you want to load a library use KPluginLoader.
+ * The application that wants to instantiate plugin classes can do the following:
+ * \code
+ * PluginFactory *factory = KPluginLoader("libraryname").factory();
+ * if (factory) {
+ *     PluginInterface *p1 = factory->create<PluginInterface>(parent);
+ *     OtherInterface *p2  = factory->create<OtherInterface>(parent);
+ *     NextInterface *p3   = factory->create<NextInterface>("keyword1", parent);
+ *     NextInterface *p3   = factory->create<NextInterface>("keyword2", parent);
+ * }
+ * \endcode
+ *
+ * \author Matthias Kretz <kretz@kde.org>
+ * \author Bernhard Loos <nhuh.put@web.de>
+ */
+class UIDLLEXPORT PluginFactory : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(PluginFactory)
+public:
+    /**
+     * This constructor creates a factory for a plugin.
+     */
+    explicit PluginFactory();
+
+    /**
+     * This destroys the PluginFactory.
+     */
+    virtual ~PluginFactory();
+
+    /**
+     * Use this method to create an object. It will try to create an object which inherits
+     * \p T. If it has multiple choices, you will get a fatal error (kFatal()), so be careful
+     * to request a unique interface or use keywords.
+     *
+     * \tparam T The interface for which an object should be created. The object will inherit \p T.
+     * \param parent The parent of the object. If \p parent is a widget type, it will also passed
+     *               to the parentWidget argument of the CreateInstanceFunction for the object.
+     * \returns A pointer to the created object is returned, or 0 if an error occurred.
+     */
+    template<typename T>
+    T *create(QObject *parent = 0);
+
+    /**
+     * Use this method to create an object. It will try to create an object which inherits
+     * \p T and was registered with \p keyword.
+     *
+     * \tparam T The interface for which an object should be created. The object will inherit \p T.
+     * \param keyword The keyword of the object.
+     * \param parent The parent of the object. If \p parent is a widget type, it will also passed
+     *               to the parentWidget argument of the CreateInstanceFunction for the object.
+     * \returns A pointer to the created object is returned, or 0 if an error occurred.
+     */
+    template<typename T>
+    T *create(const QString &keyword, QObject *parent = 0);
+
+Q_SIGNALS:
+    void objectCreated(QObject *object);
+
+protected:
+    /**
+     * Function pointer type to a function that instantiates a plugin.
+     */
+    typedef QObject *(*CreateInstanceFunction)(QWidget *, QObject *);
+
+    /**
+     * This is used to detect the arguments need for the constructor of plugin classes.
+     * You can inherit it, if you want to add new classes and still keep support for the old ones.
+     */
+    template<class impl>
+    struct InheritanceChecker {
+        CreateInstanceFunction createInstanceFunction(QWidget *)
+        {
+            return &createInstance<impl, QWidget>;
+        }
+        CreateInstanceFunction createInstanceFunction(...)
+        {
+            return &createInstance<impl, QObject>;
+        }
+    };
+
+    explicit PluginFactory(PluginFactoryPrivate &dd);
+
+    /**
+     * Registers a plugin with the factory. Call this function from the constructor of the
+     * PluginFactory subclass to make the create function able to instantiate the plugin when asked
+     * for an interface the plugin implements.
+     *
+     * \tparam T the name of the plugin class
+     *
+     * \param keyword An optional keyword as unique identifier for the plugin. This allows you to
+     * put more than one plugin with the same interface into the same library using the same
+     * factory. X-KDE-PluginKeyword is a convenient way to specify the keyword in a desktop file.
+     *
+     * \param instanceFunction A function pointer to a function that creates an instance of the
+     * plugin. The default function that will be used depends on the type of interface. If the
+     * interface inherits from
+     * \li \c KParts::Part the function will call
+     * \code
+     * new T(QWidget *parentWidget, QObject *parent)
+     * \endcode
+     * \li \c QWidget the function will call
+     * \code
+     * new T(QWidget *parent)
+     * \endcode
+     * \li else the function will call
+     * \code
+     * new T(QObject *parent)
+     * \endcode
+     */
+    template<class T>
+    void registerPlugin(const QString &keyword = QString(),
+                        CreateInstanceFunction instanceFunction
+                        = InheritanceChecker<T>().createInstanceFunction(reinterpret_cast<T *>(0)))
+    {
+        doRegisterPlugin(keyword, &T::staticMetaObject, instanceFunction);
+    }
+
+    PluginFactoryPrivate *const d_ptr;
+
+    /**
+     * This function is called when the factory asked to create an Object.
+     *
+     * You may reimplement it to provide a very flexible factory. This is especially useful to
+     * provide generic factories for plugins implemeted using a scripting language.
+     *
+     * \param iface The staticMetaObject::className() string identifying the plugin interface that
+     * was requested. E.g. for KCModule plugins this string will be "KCModule".
+     * \param parentWidget Only used if the requested plugin is a KPart.
+     * \param parent The parent object for the plugin object.
+     * \param args A plugin specific list of arbitrary arguments.
+     * \param keyword A string that uniquely identifies the plugin. If a KService is used this
+     * keyword is read from the X-KDE-PluginKeyword entry in the .desktop file.
+     */
+    virtual QObject *create(const char *iface, QWidget *parentWidget, QObject *parent, const QString &keyword);
+
+    template<class impl, class ParentType>
+    static QObject *createInstance(QWidget *parentWidget, QObject *parent)
+    {
+        Q_UNUSED(parentWidget);
+        ParentType *p = 0;
+        if (parent) {
+            p = qobject_cast<ParentType *>(parent);
+            Q_ASSERT(p);
+        }
+        return new impl(p);
+    }
+
+private:
+    void doRegisterPlugin(const QString &keyword, const QMetaObject *metaObject, CreateInstanceFunction instanceFunction);
+};
+
+template<typename T>
+inline T *PluginFactory::create(QObject *parent)
+{
+    QObject *o = create(T::staticMetaObject.className(),
+                        parent && parent->isWidgetType() ? reinterpret_cast<QWidget *>(parent) : 0,
+                        parent,
+                        QString());
+
+    T *t = qobject_cast<T *>(o);
+    if (!t) {
+        delete o;
+    }
+    return t;
+}
+
+template<typename T>
+inline T *PluginFactory::create(const QString &keyword, QObject *parent)
+{
+    QObject *o = create(T::staticMetaObject.className(),
+                        parent && parent->isWidgetType() ? reinterpret_cast<QWidget *>(parent) : 0,
+                        parent,
+                        keyword);
+
+    T *t = qobject_cast<T *>(o);
+    if (!t) {
+        delete o;
+    }
+    return t;
+}
+
+}
+
+Q_DECLARE_INTERFACE(Calamares::PluginFactory, CalamaresPluginFactory_iid)
+
+#endif // CALAMARESPLUGINFACTORY_H

src/libcalamaresui/utils/PluginFactory_p.h

+/* === This file is part of Calamares - <http://github.com/calamares> ===
+ *
+ *   Copyright 2015, Teo Mrnjavac <teo@kde.org>
+ *
+ *   Based on KPluginFactory from KCoreAddons, KDE project
+ *   Copyright 2007, Matthias Kretz <kretz@kde.org>
+ *   Copyright 2007, Bernhard Loos <nhuh.put@web.de>
+ *
+ *   Calamares is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   Calamares 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 General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Calamares. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CALAMARESPLUGINFACTORY_P_H
+#define CALAMARESPLUGINFACTORY_P_H
+
+#include "PluginFactory.h"
+
+#include <QtCore/QHash>
+
+namespace Calamares
+{
+
+class PluginFactoryPrivate
+{
+    Q_DECLARE_PUBLIC(PluginFactory)
+protected:
+    typedef QPair<const QMetaObject *, PluginFactory::CreateInstanceFunction> Plugin;
+
+    PluginFactoryPrivate() : catalogInitialized(false) {}
+    ~PluginFactoryPrivate()
+    {
+    }
+
+    QHash<QString, Plugin> createInstanceHash;
+    QString catalogName;
+    bool catalogInitialized;
+
+    PluginFactory *q_ptr;
+};
+
+}
+
+#endif // CALAMARESPLUGINFACTORY_P_H