AlgorithmFactory.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 "MantidAPI/DllConfig.h"
#include "MantidKernel/DynamicFactory.h"
#include "MantidKernel/SingletonHolder.h"
#include <boost/optional.hpp>
#include <memory>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace Mantid {
namespace API {
 
struct AlgorithmDescriptor {
  std::string name;     
  int version;          
  std::string category; 
  std::string alias;    
};
 
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
class IAlgorithm;
class Algorithm;
 
class MANTID_API_DLL AlgorithmFactoryImpl final : public Kernel::DynamicFactory<Algorithm> {
public:
  AlgorithmFactoryImpl(const AlgorithmFactoryImpl &) = delete;
  AlgorithmFactoryImpl &operator=(const AlgorithmFactoryImpl &) = delete;
  // Unhide the base class version (to satisfy the intel compiler)
  using Kernel::DynamicFactory<Algorithm>::create;
  std::shared_ptr<Algorithm> create(const std::string &, const int &) const;
 
  template <class C> std::pair<std::string, int> subscribe() {
    std::unique_ptr<Kernel::AbstractInstantiator<Algorithm>> newI =
        std::make_unique<Kernel::Instantiator<C, Algorithm>>();
    return this->subscribe(std::move(newI));
  }
 
  template <class T>
  std::pair<std::string, int> subscribe(std::unique_ptr<Kernel::AbstractInstantiator<T>> instantiator,
                                        const SubscribeAction replaceExisting = ErrorIfExists) {
    const auto tempAlg = instantiator->createInstance();
    const int version = extractAlgVersion(tempAlg);
    const std::string className = extractAlgName(tempAlg);
    const std::string alias = extractAlgAlias(tempAlg);
    typename VersionMap::const_iterator it = m_vmap.find(className);
    if (!className.empty()) {
      const std::string key = createName(className, version);
      if (it == m_vmap.end()) {
        m_vmap[className] = version;
      } else {
        if (version == it->second && replaceExisting == ErrorIfExists) {
          std::ostringstream os;
          os << "Cannot register algorithm " << className << " twice with the same version\n";
          throw std::runtime_error(os.str());
        }
        if (version > it->second) {
          m_vmap[className] = version;
        }
      }
      Kernel::DynamicFactory<Algorithm>::subscribe(key, std::move(instantiator), replaceExisting);
    } else {
      throw std::invalid_argument("Cannot register empty algorithm name");
    }
 
    if (!alias.empty())
      m_amap[alias] = className;
 
    return std::make_pair(className, version);
  }
  void unsubscribe(const std::string &algorithmName, const int version);
  bool exists(const std::string &algorithmName, const int version = -1);
 
  const std::vector<std::string> getKeys() const override;
  const std::vector<std::string> getKeys(bool includeHidden) const;
 
  boost::optional<std::string> getRealNameFromAlias(const std::string &alias) const noexcept;
 
  int highestVersion(const std::string &algorithmName) const;
 
  const std::unordered_set<std::string> getCategories(bool includeHidden = false) const;
 
  const std::map<std::string, bool> getCategoriesWithState() const;
 
  std::vector<AlgorithmDescriptor> getDescriptors(bool includeHidden = false, bool includeAliases = false) const;
 
  std::pair<std::string, int> decodeName(const std::string &mangledName) const;
 
private:
  friend struct Mantid::Kernel::CreateUsingNew<AlgorithmFactoryImpl>;
 
  const std::string extractAlgName(const std::shared_ptr<IAlgorithm> &alg) const;
  int extractAlgVersion(const std::shared_ptr<IAlgorithm> &alg) const;
  const std::string extractAlgAlias(const std::shared_ptr<IAlgorithm> &alg) const;
 
  std::shared_ptr<Algorithm> createAlgorithm(const std::string &name, const int version) const;
 
  AlgorithmFactoryImpl();
  ~AlgorithmFactoryImpl() override;
  std::string createName(const std::string &, const int &) const;
  void fillHiddenCategories(std::unordered_set<std::string> *categorySet) const;
 
  using VersionMap = std::map<std::string, int>;
  VersionMap m_vmap;
  using AliasMap = std::unordered_map<std::string, std::string>;
  AliasMap m_amap;
};
 
using AlgorithmFactory = Mantid::Kernel::SingletonHolder<AlgorithmFactoryImpl>;
 
using AlgorithmFactoryUpdateNotification = Mantid::Kernel::DynamicFactory<Algorithm>::UpdateNotification;
using AlgorithmFactoryUpdateNotification_ptr =
    const Poco::AutoPtr<Mantid::Kernel::DynamicFactory<Algorithm>::UpdateNotification> &;
 
} // namespace API
} // namespace Mantid
 
namespace Mantid {
namespace Kernel {
EXTERN_MANTID_API template class MANTID_API_DLL Mantid::Kernel::SingletonHolder<Mantid::API::AlgorithmFactoryImpl>;
}
} // namespace Mantid