Enhanced to function pointer backend to handle custom parameter types.

Libs/CommandLineModules/Backend/FunctionPointer/ctkCmdLineModuleBackendFPTypeTraits.h

@@ -86,6 +86,37 @@ public:
                                      typename Select<isReference, typename UnConst<ReferenceType>::Result, typename UnConst<T>::Result>::Result >::Result RawType;
 };
 
+template<bool C, typename T = void>
+struct EnableIf
+{
+  typedef T Type;
+};
+
+template<typename T>
+struct EnableIf<false, T> {};
+
+template<typename, typename>
+struct IsSame
+{
+  static bool const value = false;
+};
+
+template<typename A>
+struct IsSame<A, A>
+{
+  static bool const value = true;
+};
+
+template<typename B, typename D>
+struct IsBaseOf
+{
+  static D* MakeD();
+  static char (& Test(B*))[1];
+  static char (& Test(...))[2];
+  static bool const value = sizeof Test(MakeD()) == 1 &&
+      !IsSame<B volatile const, void volatile const>::value;
+};
+
 
 }
 }

Libs/CommandLineModules/Backend/FunctionPointer/ctkCmdLineModuleBackendFPUtil_p.h

@@ -22,6 +22,8 @@
 #ifndef CTKCMDLINEMODULEBACKENDFPUTIL_P_H
 #define CTKCMDLINEMODULEBACKENDFPUTIL_P_H
 
+#include "ctkCommandLineModulesBackendFunctionPointerExport.h"
+
 #include <QVariant>
 
 class ctkCmdLineModuleBackendFunctionPointer;
@@ -29,7 +31,7 @@ class ctkCmdLineModuleBackendFunctionPointer;
 namespace ctk {
 namespace CmdLineModuleBackendFunctionPointer {
 
-struct FunctionPointerHolderBase
+struct CTK_CMDLINEMODULEBACKENDFP_EXPORT FunctionPointerHolderBase
 {
   virtual ~FunctionPointerHolderBase();
 
@@ -84,7 +86,7 @@ struct FunctionPointerHolder2 : public FunctionPointerHolderBase
   FunctionPointerType Fp;
 };
 
-struct FunctionPointerProxy
+struct CTK_CMDLINEMODULEBACKENDFP_EXPORT FunctionPointerProxy
 {
   FunctionPointerProxy();
   ~FunctionPointerProxy();

Libs/CommandLineModules/Backend/FunctionPointer/ctkCmdLineModuleBackendFunctionPointer.cpp

@@ -177,6 +177,11 @@ ctkCmdLineModuleBackendFunctionPointer::ctkCmdLineModuleBackendFunctionPointer()
 }
 
 //----------------------------------------------------------------------------
+ctkCmdLineModuleBackendFunctionPointer::~ctkCmdLineModuleBackendFunctionPointer()
+{
+}
+
+//----------------------------------------------------------------------------
 QString ctkCmdLineModuleBackendFunctionPointer::name() const
 {
   return "Function Pointer (experimental)";
@@ -206,6 +211,7 @@ qint64 ctkCmdLineModuleBackendFunctionPointer::timeStamp(const QUrl &location) c
 QByteArray ctkCmdLineModuleBackendFunctionPointer::rawXmlDescription(const QUrl& location)
 {
   if (!d->UrlToFpDescription.contains(location)) return QByteArray();
+  qDebug() << d->UrlToFpDescription[location].d->xmlDescription();
   return QByteArray(qPrintable(d->UrlToFpDescription[location].d->xmlDescription()));
 }
 
@@ -215,7 +221,7 @@ ctkCmdLineModuleFuture ctkCmdLineModuleBackendFunctionPointer::run(ctkCmdLineMod
   QUrl url = frontend->location();
 
   const Description& descr = d->UrlToFpDescription[url];
-  QList<QVariant> args = frontend->values().values();
+  QList<QVariant> args = this->arguments(frontend);
 
   // Instances of ctkCmdLineModuleFunctionPointerTask are auto-deleted by the
   // thread pool
@@ -224,6 +230,12 @@ ctkCmdLineModuleFuture ctkCmdLineModuleBackendFunctionPointer::run(ctkCmdLineMod
 }
 
 //----------------------------------------------------------------------------
+QList<QVariant> ctkCmdLineModuleBackendFunctionPointer::arguments(ctkCmdLineModuleFrontend *frontend) const
+{
+  return frontend->values().values();
+}
+
+//----------------------------------------------------------------------------
 QList<QUrl> ctkCmdLineModuleBackendFunctionPointer::registeredFunctionPointers() const
 {
   return d->UrlToFpDescription.keys();

Libs/CommandLineModules/Backend/FunctionPointer/ctkCmdLineModuleBackendFunctionPointer.h

@@ -26,6 +26,7 @@
 
 #include "ctkCommandLineModulesBackendFunctionPointerExport.h"
 #include "ctkCmdLineModuleBackendFPTypeTraits.h"
+#include "ctkCmdLineModuleBackendFPUtil_p.h"
 
 #include <QScopedPointer>
 #include <QSharedPointer>
@@ -44,6 +45,45 @@ struct FunctionPointerProxy;
 template<typename T>
 QString GetParameterTypeName();
 
+struct ImageType {};
+
+// default parameter description
+template<typename T, typename Enable = void>
+struct CreateXmlFor
+{
+  static QString parameter(int index, const QString& typeName, const QString& label = QString(), const QString& description = QString())
+  {
+    QString xmlParameter;
+    QTextStream str(&xmlParameter);
+    str << "    <" << typeName << ">\n";
+    str << "      <name>" << QString("param%1").arg(index) << "</name>\n";
+    str << "      <index>" << index << "</index>\n";
+    str << "      <description>" << (description.isEmpty() ? "Description not available." : description) << "</description>\n";
+    str << "      <label>" << (label.isEmpty() ? QString("Parameter %1").arg(index) : label) << "</label>\n";
+    str << "    </" << typeName << ">\n";
+    return xmlParameter;
+  }
+};
+
+// specialization for input image types
+template<typename T>
+struct CreateXmlFor<T, typename EnableIf<IsBaseOf<ImageType, T>::value >::Type >
+{
+  static QString parameter(int index, const QString& typeName, const QString& label = QString(), const QString& description = QString())
+  {
+    QString xmlParameter;
+    QTextStream str(&xmlParameter);
+    str << "    <" << typeName << ">\n";
+    str << "      <name>" << QString("param%1").arg(index) << "</name>\n";
+    str << "      <index>" << index << "</index>\n";
+    str << "      <description>" << (description.isEmpty() ? "Description not available." : description) << "</description>\n";
+    str << "      <label>" << (label.isEmpty() ? QString("Parameter %1").arg(index) : label) << "</label>\n";
+    str << "      <channel>input</channel>\n";
+    str << "    </" << typeName << ">\n";
+    return xmlParameter;
+  }
+};
+
 }
 }
 
@@ -93,6 +133,7 @@ public:
   };
 
   ctkCmdLineModuleBackendFunctionPointer();
+  ~ctkCmdLineModuleBackendFunctionPointer();
 
   virtual QString name() const;
   virtual QString description() const;
@@ -103,16 +144,19 @@ public:
 
   virtual QByteArray rawXmlDescription(const QUrl& location);
 
-  virtual ctkCmdLineModuleFuture run(ctkCmdLineModuleFrontend *frontend);
-
   QList<QUrl> registeredFunctionPointers() const;
 
   template<typename A>
   Description* registerFunctionPointer(const QString& title, void (*fp)(A),
                                        const QString& paramLabel = QString(), const QString& paramDescr = QString())
   {
+    typedef typename ctk::CmdLineModuleBackendFunctionPointer::TypeTraits<A>::RawType RawTypeA;
+
     QList<QString> params;
-    params << CreateXmlForParameter<A>(0, paramLabel, paramDescr);
+    params << ctk::CmdLineModuleBackendFunctionPointer::CreateXmlFor<RawTypeA>::
+              parameter(0,
+                        ctk::CmdLineModuleBackendFunctionPointer::GetParameterTypeName<RawTypeA>(),
+                        paramLabel, paramDescr);
     return this->registerFunctionPointerProxy(title, ctk::CmdLineModuleBackendFunctionPointer::FunctionPointerProxy(fp), params);
   }
 
@@ -121,35 +165,37 @@ public:
                                        const QString& paramLabel0 = QString(), const QString& paramDescr0 = QString(),
                                        const QString& paramLabel1 = QString(), const QString& paramDescr1 = QString())
   {
+    typedef typename ctk::CmdLineModuleBackendFunctionPointer::TypeTraits<A>::RawType RawTypeA;
+    typedef typename ctk::CmdLineModuleBackendFunctionPointer::TypeTraits<B>::RawType RawTypeB;
+
     QList<QString> params;
-    params << CreateXmlForParameter<A>(0, paramLabel0, paramDescr0);
-    params << CreateXmlForParameter<B>(1, paramLabel1, paramDescr1);
+    params << ctk::CmdLineModuleBackendFunctionPointer::CreateXmlFor<RawTypeA>::
+              parameter(0,
+                        ctk::CmdLineModuleBackendFunctionPointer::GetParameterTypeName<RawTypeA>(),
+                        paramLabel0, paramDescr0);
+    params << ctk::CmdLineModuleBackendFunctionPointer::CreateXmlFor<RawTypeB>::
+              parameter(1,
+                        ctk::CmdLineModuleBackendFunctionPointer::GetParameterTypeName<RawTypeB>(),
+                        paramLabel1, paramDescr1);
     return this->registerFunctionPointerProxy(title, ctk::CmdLineModuleBackendFunctionPointer::FunctionPointerProxy(fp), params);
   }
 
+protected:
+
+  virtual ctkCmdLineModuleFuture run(ctkCmdLineModuleFrontend* frontend);
+
+  virtual QList<QVariant> arguments(ctkCmdLineModuleFrontend* frontend) const;
+
 private:
 
   Description* registerFunctionPointerProxy(const QString &title,
                                             const ctk::CmdLineModuleBackendFunctionPointer::FunctionPointerProxy& proxy,
                                             const QList<QString>& params);
 
-  template<typename T>
-  QString CreateXmlForParameter(int index, const QString& label = QString(), const QString& description = QString())
-  {
-    QString xmlParameter;
-    QTextStream str(&xmlParameter);
-    QString typeName = ctk::CmdLineModuleBackendFunctionPointer::GetParameterTypeName<typename ctk::CmdLineModuleBackendFunctionPointer::TypeTraits<T>::RawType>();
-    str << "    <" << typeName << ">\n";
-    str << "      <name>" << QString("param%1").arg(index) << "</name>\n";
-    str << "      <index>" << index << "</index>\n";
-    str << "      <description>" << (description.isEmpty() ? "Description not available." : description) << "</description>\n";
-    str << "      <label>" << (label.isEmpty() ? QString("Parameter %1").arg(index) : label) << "</label>\n";
-    str << "    </" << typeName << ">\n";
-    return xmlParameter;
-  }
 
   QScopedPointer<ctkCmdLineModuleBackendFunctionPointerPrivate> d;
 
 };
 
+
 #endif // CTKCMDLINEMODULEBACKENDFUNCTIONPOINTER_H