Merge branch 'fix-library-item-resolve-method'

* fix-library-item-resolve-method:
  ctkFactoryLibraryItem::symbolAddress can be usedfor non mandatory symbol
  ctkFactoryLibraryItem::resolve - Improve/add debug messages
  Factory - Add method allowing to log loading warnings/errors
  Revert "Try loading as many symbols as possible"

Libs/Core/ctkAbstractFactory.h

@@ -45,12 +45,14 @@ public:
   //explicit ctkAbstractFactoryItem();
   ctkAbstractFactoryItem();
 
-  virtual QString loadErrorString()const;
   virtual bool load() = 0;
 
   QStringList instantiateErrorStrings()const;
   QStringList instantiateWarningStrings()const;
 
+  QStringList loadErrorStrings()const;
+  QStringList loadWarningStrings()const;
+
   BaseClassType* instantiate();
   bool instantiated()const;
   virtual void uninstantiate();
@@ -66,6 +68,12 @@ protected:
   void appendInstantiateWarningString(const QString& msg);
   void clearInstantiateWarningStrings();
 
+  void appendLoadErrorString(const QString& msg);
+  void clearLoadErrorStrings();
+
+  void appendLoadWarningString(const QString& msg);
+  void clearLoadWarningStrings();
+
   /// Must be reimplemented in subclasses to instanciate a BaseClassType*
   virtual BaseClassType* instanciator() = 0;
   BaseClassType* Instance;
@@ -73,6 +81,8 @@ protected:
 private:
   QStringList InstantiateErrorStrings;
   QStringList InstantiateWarningStrings;
+  QStringList LoadErrorStrings;
+  QStringList LoadWarningStrings;
   bool Verbose;
 };
 

Libs/Core/ctkAbstractFactory.tpp

@@ -40,13 +40,6 @@ ctkAbstractFactoryItem<BaseClassType>::ctkAbstractFactoryItem()
 
 //----------------------------------------------------------------------------
 template<typename BaseClassType>
-QString ctkAbstractFactoryItem<BaseClassType>::loadErrorString()const
-{ 
-  return QString(); 
-}
-
-//----------------------------------------------------------------------------
-template<typename BaseClassType>
 QStringList ctkAbstractFactoryItem<BaseClassType>::instantiateErrorStrings()const
 {
   return this->InstantiateErrorStrings;
@@ -88,6 +81,48 @@ void ctkAbstractFactoryItem<BaseClassType>::clearInstantiateWarningStrings()
 }
 
 //----------------------------------------------------------------------------
+template<typename BaseClassType>
+QStringList ctkAbstractFactoryItem<BaseClassType>::loadErrorStrings()const
+{
+  return this->LoadErrorStrings;
+}
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+void ctkAbstractFactoryItem<BaseClassType>::appendLoadErrorString(const QString& errorString)
+{
+  this->LoadErrorStrings << errorString;
+}
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+void ctkAbstractFactoryItem<BaseClassType>::clearLoadErrorStrings()
+{
+  this->LoadErrorStrings.clear();
+}
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+QStringList ctkAbstractFactoryItem<BaseClassType>::loadWarningStrings()const
+{
+  return this->LoadWarningStrings;
+}
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+void ctkAbstractFactoryItem<BaseClassType>::appendLoadWarningString(const QString& msg)
+{
+  this->LoadWarningStrings << msg;
+}
+
+//----------------------------------------------------------------------------
+template<typename BaseClassType>
+void ctkAbstractFactoryItem<BaseClassType>::clearLoadWarningStrings()
+{
+  this->LoadWarningStrings.clear();
+}
+
+//----------------------------------------------------------------------------
 template<typename BaseClassType>  
 BaseClassType* ctkAbstractFactoryItem<BaseClassType>::instantiate()
 {
@@ -295,10 +330,19 @@ bool ctkAbstractFactory<BaseClassType>::registerItem(const QString& key,
   if (!_item->load())
     {
     this->displayStatusMessage(QtCriticalMsg, description, "Failed", this->verbose());
-    if (this->verbose() && !_item->loadErrorString().isEmpty())
+    if(!_item->loadErrorStrings().isEmpty())
       {
       qCritical().nospace() << qPrintable(QString(" ").repeated(2) + QLatin1String("Error(s):\n"))
-                            << qPrintable(QString(" ").repeated(4) + _item->loadErrorString());
+                            << qPrintable(QString(" ").repeated(4) +
+                                          _item->loadErrorStrings().join(
+                                            QString("\n") + QString(" ").repeated(4)));
+      }
+    if(!_item->loadWarningStrings().isEmpty())
+      {
+      qWarning().nospace() << qPrintable(QString(" ").repeated(2) + QLatin1String("Warning(s):\n"))
+                           << qPrintable(QString(" ").repeated(4) +
+                                         _item->loadWarningStrings().join(
+                                           QString("\n") + QString(" ").repeated(4)));
       }
     return false;
     }

Libs/Core/ctkAbstractLibraryFactory.h

@@ -42,7 +42,6 @@ public:
   //explicit ctkFactoryLibraryItem(const QString& path);
  
   virtual bool load();
-  virtual QString loadErrorString()const;
 
   ///
   /// Set list of required symbols
@@ -59,7 +58,7 @@ public:
   void* symbolAddress(const QString& symbol)const;
 
 protected:
-  QLibrary              Library;
+  mutable QLibrary      Library;
   QHash<QString, void*> ResolvedSymbols;
   QStringList           Symbols;
 };

Libs/Core/ctkAbstractLibraryFactory.tpp

@@ -44,22 +44,20 @@ bool ctkFactoryLibraryItem<BaseClassType>::load()
     {
     if (!this->resolve())
       {
+      this->appendLoadErrorString(this->Library.errorString());
       return false;
       }
     return true;
     }
+  else
+    {
+    this->appendLoadErrorString(this->Library.errorString());
+    }
   return false;
 }
 
 //----------------------------------------------------------------------------
 template<typename BaseClassType>
-QString ctkFactoryLibraryItem<BaseClassType>::loadErrorString()const
-{
-  return this->Library.errorString();
-}
-
-//----------------------------------------------------------------------------
-template<typename BaseClassType>
 void ctkFactoryLibraryItem<BaseClassType>::setSymbols(const QStringList& symbols)
 { 
   this->Symbols = symbols; 
@@ -69,38 +67,31 @@ void ctkFactoryLibraryItem<BaseClassType>::setSymbols(const QStringList& symbols
 template<typename BaseClassType>
 bool ctkFactoryLibraryItem<BaseClassType>::resolve()
 {
-  bool res = true;
   foreach(const QString& symbol, this->Symbols)
     {
     // Sanity checks
     if (symbol.isEmpty()) 
-      { 
-      continue; 
+      {
+      this->appendLoadErrorString(QLatin1String("Failed to resolve empty symbol !"));
+      continue;
       }
-      
-    // Make sure the symbols haven't been registered
+
+    // Skip if the symbols has already been resolved
     if (this->ResolvedSymbols.contains(symbol))
       {
-      if (this->verbose())
-        {
-        qWarning() << "Symbol '" << symbol << "' already resolved - Path:" << this->path();
-        }
+      this->appendLoadWarningString(QString("Symbol '%1' already resolved").arg(symbol));
       continue;
       }
 
     void * resolvedSymbol = this->Library.resolve(symbol.toLatin1());
     if (!resolvedSymbol)
       {
-      if (this->verbose())
-        {
-        qWarning() << "Symbol '" << symbol << "' can't be found.";
-        }
-      res = false;
-      continue;
+      this->appendLoadErrorString(QString("Failed to resolve mandatory symbol '%1'").arg(symbol));
+      return false;
       }
     this->ResolvedSymbols[symbol] = resolvedSymbol;
     }
-  return res;
+  return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -108,11 +99,9 @@ template<typename BaseClassType>
 void* ctkFactoryLibraryItem<BaseClassType>::symbolAddress(const QString& symbol)const
 {
   ConstIterator iter = this->ResolvedSymbols.find(symbol);
-  
-  Q_ASSERT(iter != this->ResolvedSymbols.constEnd());
   if ( iter == this->ResolvedSymbols.constEnd())
     {
-    return 0;
+    return this->Library.resolve(symbol.toLatin1());
     }
   return iter.value();
 }