HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1156:bdd9ca279197

Merge pull request from SciQLop-IPSIS-fork StaticPlugins...

perrinel -

r1156:bdd9ca279197

parent child

Context file:

r1156:bdd9ca279197

app/src/Main.cpp +9 0

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program 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 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program 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 this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
+            #include <QtPlugin>
             #include <Plugin/PluginManager.h>
             #include <QDir>
             #include <QLoggingCategory>
             Q_LOGGING_CATEGORY(LOG_Main, "Main")
             namespace {
             const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
             } // namespace
             int main(int argc, char *argv[])
             {
+            #ifdef QT_STATICPLUGIN
+                Q_IMPORT_PLUGIN(MockPlugin)
+                Q_IMPORT_PLUGIN(AmdaPlugin)
+                Q_INIT_RESOURCE(amdaresources);
+            #endif
+                Q_INIT_RESOURCE(sqpguiresources);
                 SqpApplication a{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 MainWindow w;
                 w.show();
                 // Loads plugins
                 auto pluginDir = QDir{a.applicationDirPath()};
                 auto pluginLookupPath = {
                     a.applicationDirPath(),
                     a.applicationDirPath() + "/" + PLUGIN_DIRECTORY_NAME,
                     a.applicationDirPath() + "/../lib64/SciQlop",
                     a.applicationDirPath() + "/../lib64/sciqlop",
                     a.applicationDirPath() + "/../lib/SciQlop",
                     a.applicationDirPath() + "/../lib/sciqlop",
                     a.applicationDirPath() + "/../plugins",
                 };
             #if _WIN32 || _WIN64
                 pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
                 pluginDir.cd(PLUGIN_DIRECTORY_NAME);
             #endif
                 PluginManager pluginManager{};
                 for (auto &&path : pluginLookupPath) {
                     QDir directory{path};
                     if (directory.exists()) {
                         qCDebug(LOG_Main())
                             << QObject::tr("Plugin directory: %1").arg(directory.absolutePath());
                         pluginManager.loadPlugins(directory);
                     }
                 }
+                pluginManager.loadStaticPlugins();
                 return a.exec();
             }

core/include/Plugin/PluginManager.h +6 -1

             #ifndef SCIQLOP_PLUGINMANAGER_H
             #define SCIQLOP_PLUGINMANAGER_H
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             class QDir;
             Q_DECLARE_LOGGING_CATEGORY(LOG_PluginManager)
             /**
              * @brief The PluginManager class aims to handle the plugins loaded dynamically into SciQLop.
              */
             class SCIQLOP_CORE_EXPORT PluginManager {
             public:
                 explicit PluginManager();
                 /**
                  * Loads plugins into SciQlop. The loaded plugins are those located in the directory passed in
                  * parameter
                  * @param pluginDir the directory containing the plugins
                  */
                 void loadPlugins(const QDir &pluginDir);
+                /**
+                 * Loads static plugins into SciQlop. SciQLOP supports statically linked plugins.
+                 */
+                void loadStaticPlugins();
                 /// @returns the number of plugins loaded
                 int nbPluginsLoaded() const noexcept;
             private:
-                class PluginManagerPrivate;
+                struct PluginManagerPrivate;
                 spimpl::unique_impl_ptr<PluginManagerPrivate> impl;
             };
             #endif // SCIQLOP_PLUGINMANAGER_H

core/src/Plugin/PluginManager.cpp +14 0

             #include <Plugin/PluginManager.h>
             #include <Plugin/IPlugin.h>
             #include <QDir>
             #include <QLibrary>
             #include <QPluginLoader>
             Q_LOGGING_CATEGORY(LOG_PluginManager, "PluginManager")
             namespace {
             /// Key for retrieving metadata of the plugin
             const auto PLUGIN_METADATA_KEY = QStringLiteral("MetaData");
             /// Key for retrieving the name of the plugin in its metadata
             const auto PLUGIN_NAME_KEY = QStringLiteral("name");
             /// Helper to state the plugin loading operation
             struct LoadPluginState {
                 explicit LoadPluginState(const QString &pluginPath)
                         : m_PluginPath{pluginPath}, m_Valid{true}, m_ErrorMessage{}
                 {
                 }
                 void log() const
                 {
                     if (m_Valid) {
                         qCDebug(LOG_PluginManager())
                             << QObject::tr("File '%1' has been loaded as a plugin").arg(m_PluginPath);
                     }
                     else {
                         qCWarning(LOG_PluginManager())
                             << QObject::tr("File '%1' can't be loaded as a plugin: %2")
                                    .arg(m_PluginPath)
                                    .arg(m_ErrorMessage);
                     }
                 }
                 void setError(const QString &errorMessage)
                 {
                     m_Valid = false;
                     m_ErrorMessage = errorMessage;
                 }
                 QString m_PluginPath;
                 bool m_Valid;
                 QString m_ErrorMessage;
             };
             } // namespace
             struct PluginManager::PluginManagerPrivate {
                 /**
                  * Loads a single plugin into SciQlop. The method has no effect if the plugin is malformed (e.g.
                  * wrong library type, missing metadata, etc.)
                  * @param pluginPath the path to the plugin library.
                  */
                 void loadPlugin(const QString &pluginPath)
                 {
                     qCDebug(LOG_PluginManager())
                         << QObject::tr("Attempting to load file '%1' as a plugin").arg(pluginPath);
                     LoadPluginState loadState{pluginPath};
                     if (QLibrary::isLibrary(pluginPath)) {
                         QPluginLoader pluginLoader{pluginPath};
                         // Retrieving the plugin name to check if it can be loaded (i.e. no plugin with the same
                         // name has been registered yet)
                         auto metadata = pluginLoader.metaData().value(PLUGIN_METADATA_KEY).toObject();
                         auto pluginName = metadata.value(PLUGIN_NAME_KEY).toString();
                         if (pluginName.isEmpty()) {
                             loadState.setError(QObject::tr("empty file name"));
                         }
                         else if (m_RegisteredPlugins.contains(pluginName)) {
                             loadState.setError(QObject::tr("name '%1' already registered").arg(pluginName));
                         }
                         else {
                             if (auto pluginInstance = qobject_cast<IPlugin *>(pluginLoader.instance())) {
                                 pluginInstance->initialize();
                                 m_RegisteredPlugins.insert(pluginName, pluginPath);
                             }
                             else {
                                 loadState.setError(QObject::tr("the file is not a Sciqlop plugin"));
                             }
                         }
                     }
                     else {
                         loadState.setError(QObject::tr("the file is not a library"));
                     }
                     // Log loading result
                     loadState.log();
                 }
+                void loadStaticPlugins()
+                {
+                    for (QObject *plugin : QPluginLoader::staticInstances())
+                    {
+                        qobject_cast<IPlugin *>(plugin)->initialize();
+                        m_RegisteredPlugins.insert(plugin->metaObject()->className(), "StaticPlugin");
+                    }
+                }
                 /// Registered plugins (key: plugin name, value: plugin path)
                 QHash<QString, QString> m_RegisteredPlugins;
             };
             PluginManager::PluginManager() : impl{spimpl::make_unique_impl<PluginManagerPrivate>()}
             {
             }
             void PluginManager::loadPlugins(const QDir &pluginDir)
             {
                 // Load plugins
                 auto pluginInfoList
                     = pluginDir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
                 for (auto entryInfo : qAsConst(pluginInfoList)) {
                     if (entryInfo.isDir()) {
                         this->loadPlugins(QDir{entryInfo.absoluteFilePath()});
                     }
                     else if (QLibrary::isLibrary(entryInfo.absoluteFilePath())) {
                         impl->loadPlugin(entryInfo.absoluteFilePath());
                     }
                 }
             }
+            void PluginManager::loadStaticPlugins()
+            {
+                impl->loadStaticPlugins();
+            }
             int PluginManager::nbPluginsLoaded() const noexcept
             {
                 return impl->m_RegisteredPlugins.size();
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages