STYLE: Remove unused parameter from SetGlobalInstance and Singleton

Added overloads of `SetGlobalInstance` and `Singleton` without the unused `func`
parameter. Let the new `SetGlobalInstance` overload just return `void`, instead
of `bool`. Deprecated the original overloads, and made them
`ITK_FUTURE_LEGACY_REMOVE`.

Follow-up to:

pull request #4164
commit 6d1c4c7
"STYLE: SingletonIndex does not need to store the unused `func` parameter"

pull request #4162
commit 6ec6328
"STYLE: Let `Singleton` assume that SetGlobalInstance always returns true"

Author: N-Dekker

Modules/Core/Common/include/itkSingleton.h

@@ -64,20 +64,29 @@ class ITKCommon_EXPORT SingletonIndex
   }
 
 
-  // Returns true.
-  //
   // It is assumed that the global will remain valid until the start
   // of globals being destroyed.
   template <typename T>
-  bool
+  void
+  SetGlobalInstance(const char * globalName, T * global, std::function<void()> deleteFunc)
+  {
+    this->SetGlobalInstancePrivate(globalName, global, deleteFunc);
+  }
+
+#ifndef ITK_FUTURE_LEGACY_REMOVE
+  template <typename T>
+  [[deprecated("Prefer calling the SetGlobalInstance(globalName, global, deleteFunc) overload (without the unused func "
+               "parameter)!")]] bool
   SetGlobalInstance(const char *                globalName,
                     T *                         global,
                     std::function<void(void *)> itkNotUsed(func),
                     std::function<void()>       deleteFunc)
   {
-    this->SetGlobalInstancePrivate(globalName, global, deleteFunc);
+    this->SetGlobalInstance(globalName, global, deleteFunc);
+    // Just returns true for backward compatibility (legacy only).
     return true;
   }
+#endif
 
   /** Set/Get the pointer to GlobalSingleton.
    * Note that SetGlobalSingleton is not concurrent thread safe. */
@@ -114,18 +123,29 @@ class ITKCommon_EXPORT SingletonIndex
 // A wrapper for a global variable registered in the singleton index.
 template <typename T>
 T *
-Singleton(const char * globalName, std::function<void(void *)> itkNotUsed(func), std::function<void()> deleteFunc)
+Singleton(const char * globalName, std::function<void()> deleteFunc)
 {
   static SingletonIndex * singletonIndex = SingletonIndex::GetInstance();
   Unused(singletonIndex);
   T * instance = SingletonIndex::GetInstance()->GetGlobalInstance<T>(globalName);
   if (instance == nullptr)
   {
     instance = new T;
-    SingletonIndex::GetInstance()->SetGlobalInstance<T>(globalName, instance, {}, deleteFunc);
+    SingletonIndex::GetInstance()->SetGlobalInstance<T>(globalName, instance, deleteFunc);
   }
   return instance;
 }
+
+
+#ifndef ITK_FUTURE_LEGACY_REMOVE
+template <typename T>
+[[deprecated("Prefer calling the Singleton(globalName, deleteFunc) overload (without the unused func parameter)!")]] T *
+Singleton(const char * globalName, std::function<void(void *)> itkNotUsed(func), std::function<void()> deleteFunc)
+{
+  return Singleton<T>(globalName, deleteFunc);
+}
+#endif
+
 } // end namespace itk
 
 #endif

Modules/Core/Common/include/itkSingletonMacro.h

@@ -49,7 +49,7 @@
         m_##VarName = nullptr;                                                                      \
       };                                                                                            \
       auto * old_instance = SingletonIndex::GetInstance()->GetGlobalInstance<Type>(#SingletonName); \
-      m_##VarName = Singleton<Type>(#SingletonName, {}, deleteLambda);                              \
+      m_##VarName = Singleton<Type>(#SingletonName, deleteLambda);                                  \
       if (old_instance == nullptr)                                                                  \
       {                                                                                             \
         Init;                                                                                       \

Modules/Core/Common/src/itkObjectFactoryBase.cxx

@@ -130,8 +130,7 @@ auto
 ObjectFactoryBase::GetPimplGlobalsPointer() -> ObjectFactoryBasePrivate *
 {
   const auto                 deleteLambda = []() { m_PimplGlobals->UnRegister(); };
-  ObjectFactoryBasePrivate * globalInstance =
-    Singleton<ObjectFactoryBasePrivate>("ObjectFactoryBase", SynchronizeObjectFactoryBase, deleteLambda);
+  ObjectFactoryBasePrivate * globalInstance = Singleton<ObjectFactoryBasePrivate>("ObjectFactoryBase", deleteLambda);
   if (globalInstance != m_PimplGlobals)
   {
     SynchronizeObjectFactoryBase(globalInstance);