qSlicerAbstractModuleFactoryManager.h

Go to the documentation of this file.

/*==============================================================================

  Program: 3D Slicer

  Copyright (c) Kitware Inc.

  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

  This file was originally developed by Jean-Christophe Fillion-Robin, Kitware Inc.
  and was partially funded by NIH grant 3P41RR013218-12S1

==============================================================================*/

#ifndef __qSlicerAbstractModuleFactoryManager_h
#define __qSlicerAbstractModuleFactoryManager_h

// Qt includes
#include <QObject>
#include <QString>

// CTK includes
#include <ctkAbstractFileBasedFactory.h>

#include "qSlicerBaseQTCoreExport.h"

class qSlicerAbstractCoreModule;

class qSlicerAbstractModuleFactoryManagerPrivate;

class Q_SLICER_BASE_QTCORE_EXPORT qSlicerAbstractModuleFactoryManager : public QObject
{
  Q_OBJECT
  Q_PROPERTY(QStringList searchPaths READ searchPaths WRITE setSearchPaths)

  
  Q_PROPERTY(QStringList modulesToIgnore READ modulesToIgnore WRITE setModulesToIgnore NOTIFY modulesToIgnoreChanged)
public:
  typedef ctkAbstractFileBasedFactory<qSlicerAbstractCoreModule> qSlicerFileBasedModuleFactory;
  typedef ctkAbstractFactory<qSlicerAbstractCoreModule> qSlicerModuleFactory;

  typedef QObject Superclass;
  qSlicerAbstractModuleFactoryManager(QObject * newParent = 0);

  virtual ~qSlicerAbstractModuleFactoryManager();

  virtual void printAdditionalInfo();

  void registerFactory(qSlicerModuleFactory* factory, int priority = 0);
  void unregisterFactory(qSlicerModuleFactory* factory);
  void unregisterFactories();

  void setSearchPaths(const QStringList& searchPaths);
  QStringList searchPaths()const;

  inline void addSearchPaths(const QStringList& paths);
  inline void addSearchPath(const QString& path);

  inline void removeSearchPaths(const QStringList& paths);

  inline void removeSearchPath(const QString& path);

  void setExplicitModules(const QStringList& moduleNames);
  QStringList explicitModules()const;


  void setModulesToIgnore(const QStringList& modulesNames);
  QStringList modulesToIgnore()const;

  inline void addModuleToIgnore(const QString& moduleName);

  inline void removeModuleToIgnore(const QString& moduleName);

  QStringList ignoredModuleNames()const;

  void registerModules();

  Q_INVOKABLE void registerModule(const QFileInfo& file);

  Q_INVOKABLE QStringList registeredModuleNames() const;

  Q_INVOKABLE bool isRegistered(const QString& name)const;

  virtual void instantiateModules();

  Q_INVOKABLE QStringList instantiatedModuleNames() const;

  Q_INVOKABLE bool isInstantiated(const QString& name)const;

  Q_INVOKABLE qSlicerAbstractCoreModule* moduleInstance(const QString& moduleName)const;

  void uninstantiateModules();

  void setVerboseModuleDiscovery(bool value);

  QStringList dependentModules(const QString& module)const;

  QStringList moduleDependees(const QString& module)const;

signals:
  void modulesRegistered(const QStringList& moduleNames);
  void moduleRegistered(const QString& moduleName);

  void explicitModulesChanged(const QStringList& moduleNames);

  void modulesToIgnoreChanged(const QStringList& moduleNames);
  void moduleIgnored(const QString& moduleName);

  void modulesInstantiated(const QStringList& moduleNames);
  void moduleInstantiated(const QString& moduleName);

  void modulesAboutToBeUninstantiated(const QStringList& moduleNames);
  void moduleAboutToBeUninstantiated(const QString& moduleName);

  void modulesUninstantiated(const QStringList& moduleNames);
  void moduleUninstantiated(const QString& moduleName);

public slots:
  void setIsVerbose(bool flag);
  bool isVerbose()const;
protected:
  QScopedPointer<qSlicerAbstractModuleFactoryManagerPrivate> d_ptr;

  void registerModules(const QString& directoryPath);

  qSlicerAbstractCoreModule* instantiateModule(const QString& name);

  virtual void uninstantiateModule(const QString& moduleName);

private:
  Q_DECLARE_PRIVATE(qSlicerAbstractModuleFactoryManager);
  Q_DISABLE_COPY(qSlicerAbstractModuleFactoryManager);
};

//-----------------------------------------------------------------------------
void qSlicerAbstractModuleFactoryManager::addSearchPaths(const QStringList& paths)
{
  this->setSearchPaths(this->searchPaths() << paths);
}

//-----------------------------------------------------------------------------
void qSlicerAbstractModuleFactoryManager::addSearchPath(const QString& path)
{
  this->setSearchPaths(this->searchPaths() << path);
}

//-----------------------------------------------------------------------------
void qSlicerAbstractModuleFactoryManager::removeSearchPaths(const QStringList& paths)
{
  foreach(const QString& path, paths)
    {
    this->removeSearchPath(path);
    }
}

//-----------------------------------------------------------------------------
void qSlicerAbstractModuleFactoryManager::removeSearchPath(const QString& path)
{
  QStringList newSearchPaths = this->searchPaths();
  newSearchPaths.removeAll(path);
  this->setSearchPaths(newSearchPaths);
}

//-----------------------------------------------------------------------------
void qSlicerAbstractModuleFactoryManager::addModuleToIgnore(const QString& moduleName)
{
  QStringList modules = this->modulesToIgnore();
  if (modules.contains(moduleName))
    {
    return;
    }
  modules << moduleName;
  this->setModulesToIgnore(modules);
}

//-----------------------------------------------------------------------------
void qSlicerAbstractModuleFactoryManager::removeModuleToIgnore(const QString& moduleName)
{
  QStringList modules = this->modulesToIgnore();
  modules.removeAll(moduleName);
  this->setModulesToIgnore(modules);
}

#endif