ENH: Add setVerbose/verbose function to Factories

qWarning/qCritical/qDebug will be executed only if verbose is True

Libs/Core/ctkAbstractFactory.h

@@ -46,11 +46,14 @@ public:
   bool instantiated();
   QString key();
   virtual void uninstantiate();
+  void setVerbose(bool value);
+  bool verbose();
 protected:
   virtual BaseClassType* instanciator() = 0;
   BaseClassType* Instance;
 private:
   QString Key;
+  bool Verbose;
 };
 
 //----------------------------------------------------------------------------
@@ -85,6 +88,11 @@ public:
   /// Method provided for convenience - Should be overloaded in subclasse
   virtual void registerItems(){}
 
+  /// Enabled verbose output
+  /// Warning and error message will be printed to standard outputs
+  void setVerbose(bool value);
+  bool verbose();
+
 protected:
 
   /// 
@@ -101,6 +109,8 @@ private:
   void operator=(const ctkAbstractFactory&); /// Not implemented
 
   QHash<QString, QSharedPointer<ctkAbstractFactoryItem<BaseClassType> > > RegisteredItemMap;
+
+  bool Verbose;
 };
 
 #include "ctkAbstractFactory.tpp"

Libs/Core/ctkAbstractFactory.tpp

@@ -28,11 +28,15 @@
 #include "ctkAbstractFactory.h"
 
 //----------------------------------------------------------------------------
+// ctkAbstractFactoryItem methods
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType>
 ctkAbstractFactoryItem<BaseClassType>::ctkAbstractFactoryItem(const QString& _key)
   :Instance()
   ,Key(_key)
 {
+  this->Verbose = false;
 }
 
 //----------------------------------------------------------------------------
@@ -85,8 +89,26 @@ void ctkAbstractFactoryItem<BaseClassType>::uninstantiate()
 
 //----------------------------------------------------------------------------
 template<typename BaseClassType>
+void ctkAbstractFactoryItem<BaseClassType>::setVerbose(bool value)
+{
+  this->Verbose = value;
+}
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+bool ctkAbstractFactoryItem<BaseClassType>::verbose()
+{
+  return this->Verbose;
+}
+
+//----------------------------------------------------------------------------
+// ctkAbstractFactory methods
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
 ctkAbstractFactory<BaseClassType>::ctkAbstractFactory()
 {
+  this->Verbose = false;
 }
 
 //----------------------------------------------------------------------------
@@ -151,7 +173,10 @@ bool ctkAbstractFactory<BaseClassType>::registerItem(
       {
       errorStr = " - " + _item->loadErrorString();
       }
-    qCritical() << "Failed to load object:" << _item->key() << errorStr ;
+    if (this->verbose())
+      {
+      qCritical() << "Failed to load object:" << _item->key() << errorStr ;
+      }
     return false;
     }
   
@@ -172,4 +197,18 @@ ctkAbstractFactoryItem<BaseClassType> * ctkAbstractFactory<BaseClassType>::item(
   return iter.value().data();
 }
 
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+void ctkAbstractFactory<BaseClassType>::setVerbose(bool value)
+{
+  this->Verbose = value;
+}
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+bool ctkAbstractFactory<BaseClassType>::verbose()
+{
+  return this->Verbose;
+}
+
 #endif

Libs/Core/ctkAbstractLibraryFactory.h

@@ -43,11 +43,15 @@ public:
   QString path()const;
   virtual QString loadErrorString()const;
 
+  ///
+  /// Set list of required symbols
   void setSymbols(const QStringList& symbols);
 
   /// 
   /// Resolve symbols
-  void resolve();
+  /// Note that the function will return False if it fails to resolve on
+  /// of the required symbols set using ::setSymbols
+  bool resolve();
   
   /// 
   /// Get symbol address

Libs/Core/ctkAbstractLibraryFactory.tpp

@@ -25,6 +25,9 @@
 #include "ctkAbstractFactory.h"
 
 //----------------------------------------------------------------------------
+// ctkFactoryLibraryItem methods
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType>
 ctkFactoryLibraryItem<BaseClassType>::ctkFactoryLibraryItem(const QString& _key,
                                                             const QString& _path)
@@ -41,7 +44,10 @@ bool ctkFactoryLibraryItem<BaseClassType>::load()
   bool loaded = this->Library.load();
   if (loaded)
     {
-    this->resolve();
+    if (!this->resolve())
+      {
+      return false;
+      }
     return true;
     }
   return false;
@@ -57,7 +63,7 @@ QString ctkFactoryLibraryItem<BaseClassType>::path()const
 //----------------------------------------------------------------------------
 template<typename BaseClassType>
 QString ctkFactoryLibraryItem<BaseClassType>::loadErrorString()const
-{ 
+{
   return this->Library.errorString();
 }
 
@@ -70,7 +76,7 @@ void ctkFactoryLibraryItem<BaseClassType>::setSymbols(const QStringList& symbols
 
 //-----------------------------------------------------------------------------
 template<typename BaseClassType>
-void ctkFactoryLibraryItem<BaseClassType>::resolve()
+bool ctkFactoryLibraryItem<BaseClassType>::resolve()
 {
   foreach(const QString& symbol, this->Symbols)
     {
@@ -83,17 +89,21 @@ void ctkFactoryLibraryItem<BaseClassType>::resolve()
     // Make sure the symbols haven't been registered
     if (this->ResolvedSymbols.contains(symbol))
       {
-      qWarning() << "Symbol '" << symbol << "' already resolved - Path:" << this->Path;
+      if (this->verbose())
+        {
+        qWarning() << "Symbol '" << symbol << "' already resolved - Path:" << this->Path;
+        }
       continue;
       }
-    
+
     void * resolvedSymbol = this->Library.resolve(symbol.toLatin1());
     if (!resolvedSymbol)
       {
-      qWarning() << "Failed to resolve symbol '" << symbol << "' - Path:" << this->Path;
+      return false;
       }
     this->ResolvedSymbols[symbol] = resolvedSymbol;
     }
+  return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -110,6 +120,9 @@ void* ctkFactoryLibraryItem<BaseClassType>::symbolAddress(const QString& symbol)
   return iter.value();
 }
 
+//----------------------------------------------------------------------------
+// ctkAbstractLibraryFactory methods
+
 //-----------------------------------------------------------------------------
 template<typename BaseClassType, typename FactoryItemType>
 ctkAbstractLibraryFactory<BaseClassType, FactoryItemType>::ctkAbstractLibraryFactory()
@@ -152,6 +165,7 @@ bool ctkAbstractLibraryFactory<BaseClassType, FactoryItemType>::registerLibrary(
     }
   QSharedPointer<FactoryItemType> _item =
     QSharedPointer<FactoryItemType>(new FactoryItemType(key, file.filePath()));
+  _item->setVerbose(this->verbose());
   _item->setSymbols(this->Symbols);
   return this->registerItem(_item);
 }

Libs/Core/ctkAbstractObjectFactory.tpp

@@ -28,6 +28,9 @@
 #include <QDebug>
 
 //----------------------------------------------------------------------------
+// ctkFactoryObjectItem methods
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType, typename ClassType>
 ctkFactoryObjectItem<BaseClassType,ClassType>::ctkFactoryObjectItem(const QString& _key)
   :ctkAbstractFactoryItem<BaseClassType>(_key)
@@ -50,6 +53,9 @@ BaseClassType* ctkFactoryObjectItem<BaseClassType,ClassType>::instanciator()
 }
 
 //----------------------------------------------------------------------------
+// ctkAbstractObjectFactory methods
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType>
 ctkAbstractObjectFactory<BaseClassType>::ctkAbstractObjectFactory()
 {
@@ -74,6 +80,7 @@ bool ctkAbstractObjectFactory<BaseClassType>::registerObject(const QString& key)
   QSharedPointer<ctkFactoryObjectItem<BaseClassType, ClassType> > objectItem =
     QSharedPointer<ctkFactoryObjectItem<BaseClassType, ClassType> >(
       new ctkFactoryObjectItem<BaseClassType, ClassType>(key) );
+  objectItem->setVerbose(this->verbose());
   return this->registerItem(objectItem);
 }
 

Libs/Core/ctkAbstractPluginFactory.tpp

@@ -29,9 +29,12 @@
 #include <QDebug>
 
 //----------------------------------------------------------------------------
+// ctkFactoryPluginItem methods
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType>
 ctkFactoryPluginItem<BaseClassType>::ctkFactoryPluginItem(const QString& _key,
-                                                            const QString& _path)
+                                                          const QString& _path)
   :ctkAbstractFactoryItem<BaseClassType>(_key),Path(_path)
 {
 }
@@ -66,14 +69,20 @@ BaseClassType* ctkFactoryPluginItem<BaseClassType>::instanciator()
   QObject * object = this->Loader.instance();
   if (!object)
     {
-    qWarning() << "Failed to instantiate plugin:" << this->path();
+    if (this->verbose())
+      {
+      qWarning() << "Failed to instantiate plugin:" << this->path();
+      }
     return 0;
     }
   BaseClassType* castedObject = qobject_cast<BaseClassType*>(object);
   if (!castedObject)
     {
-    qWarning() << "Failed to access interface [" << BaseClassType::staticMetaObject.className()
+    if (this->verbose())
+      {
+      qWarning() << "Failed to access interface [" << BaseClassType::staticMetaObject.className()
                << "] in plugin:" << this->path();
+      }
     delete object; // Clean memory
     return 0;
     }
@@ -81,6 +90,9 @@ BaseClassType* ctkFactoryPluginItem<BaseClassType>::instanciator()
 }
 
 //----------------------------------------------------------------------------
+// ctkAbstractPluginFactory methods
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType, typename FactoryItemType>
 ctkAbstractPluginFactory<BaseClassType, FactoryItemType>::ctkAbstractPluginFactory():ctkAbstractFactory<BaseClassType>()
 {
@@ -112,6 +124,7 @@ bool ctkAbstractPluginFactory<BaseClassType, FactoryItemType>::registerLibrary(c
     }
   QSharedPointer<FactoryItemType> _item =
     QSharedPointer<FactoryItemType>(new FactoryItemType(key, file.filePath()));
+  _item->setVerbose(this->verbose());
   return this->registerItem(_item);
 }
 

Libs/Core/ctkAbstractQObjectFactory.tpp

@@ -28,6 +28,9 @@
 #include "ctkAbstractObjectFactory.h"
 
 //----------------------------------------------------------------------------
+// ctkAbstractQObjectFactory methods
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType>
 ctkAbstractQObjectFactory<BaseClassType>::ctkAbstractQObjectFactory()
 {