DynamicFactory.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/CaseInsensitiveMap.h"
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Instantiator.h"
#include "MantidKernel/RegistrationHelper.h"
 
// Poco
#include <Poco/Notification.h>
#include <Poco/NotificationCenter.h>
 
// std
#include <functional>
#include <iterator>
#include <memory>
#include <vector>
 
namespace Mantid {
namespace Kernel {
 
//----------------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------------
class Logger;
 
using CaseSensitiveStringComparator = std::less<std::string>;
 
template <class Base, class Comparator = CaseInsensitiveStringComparator> class DynamicFactory {
 
public:
  enum NotificationStatus { Enabled, Disabled };
  enum SubscribeAction { ErrorIfExists, OverwriteCurrent };
  DynamicFactory(const DynamicFactory &) = delete;
  DynamicFactory &operator=(const DynamicFactory &) = delete;
 
  class DynamicFactoryNotification : public Poco::Notification {};
  class UpdateNotification : public DynamicFactoryNotification {};
 
  void enableNotifications() { m_notifyStatus = Enabled; }
 
  void disableNotifications() { m_notifyStatus = Disabled; }
 
  using AbstractFactory = AbstractInstantiator<Base>;
  virtual ~DynamicFactory() = default;
 
  virtual std::shared_ptr<Base> create(const std::string &className) const {
    auto it = _map.find(className);
    if (it != _map.end())
      return it->second->createInstance();
    else
      throw Exception::NotFoundError("DynamicFactory: " + className + " is not registered.\n", className);
  }
 
  virtual Base *createUnwrapped(const std::string &className) const {
    auto it = _map.find(className);
    if (it != _map.end())
      return it->second->createUnwrappedInstance();
    else
      throw Exception::NotFoundError("DynamicFactory: " + className + " is not registered.\n", className);
  }
 
  template <class C> void subscribe(const std::string &className) {
    subscribe(className, std::make_unique<Instantiator<C, Base>>());
  }
 
  void subscribe(const std::string &className, std::unique_ptr<AbstractFactory> pAbstractFactory,
                 SubscribeAction replace = ErrorIfExists) {
    if (className.empty()) {
      throw std::invalid_argument("Cannot register empty class name");
    }
 
    auto it = _map.find(className);
    if (it == _map.end() || replace == OverwriteCurrent) {
      _map[className] = std::move(pAbstractFactory);
      sendUpdateNotificationIfEnabled();
    } else {
      throw std::runtime_error(className + " is already registered.\n");
    }
  }
 
  void unsubscribe(const std::string &className) {
    auto it = _map.find(className);
    if (!className.empty() && it != _map.end()) {
      _map.erase(it);
      sendUpdateNotificationIfEnabled();
    } else {
      throw Exception::NotFoundError("DynamicFactory:" + className + " is not registered.\n", className);
    }
  }
 
  bool exists(const std::string &className) const { return _map.find(className) != _map.end(); }
 
  virtual const std::vector<std::string> getKeys() const {
    std::vector<std::string> names;
    names.reserve(_map.size());
    std::transform(
        _map.cbegin(), _map.cend(), std::back_inserter(names),
        [](const std::pair<const std::string, std::unique_ptr<AbstractFactory>> &mapPair) { return mapPair.first; });
    return names;
  }
 
  Poco::NotificationCenter notificationCenter;
 
protected:
  DynamicFactory() : notificationCenter(), _map(), m_notifyStatus(Disabled) {}
 
private:
  void sendUpdateNotificationIfEnabled() {
    if (m_notifyStatus == Enabled)
      sendUpdateNotification();
  }
  void sendUpdateNotification() { notificationCenter.postNotification(new UpdateNotification); }
 
  using FactoryMap = std::map<std::string, std::unique_ptr<AbstractFactory>, Comparator>;
  FactoryMap _map;
  NotificationStatus m_notifyStatus;
};
 
} // namespace Kernel
} // namespace Mantid