FunctionFactory.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 "MantidAPI/IPeakFunction.h"
#include "MantidKernel/DynamicFactory.h"
#include "MantidKernel/SingletonHolder.h"
#include <vector>
 
#include <mutex>
 
namespace Mantid {
 
namespace API {
 
//----------------------------------------------------------------------
// More forward declarations
//----------------------------------------------------------------------
class IFunction;
class CompositeFunction;
class Expression;
class MultiDomainFunction;
 
class MANTID_API_DLL FunctionFactoryImpl final : public Kernel::DynamicFactory<IFunction> {
public:
  FunctionFactoryImpl(const FunctionFactoryImpl &) = delete;
  FunctionFactoryImpl &operator=(const FunctionFactoryImpl &) = delete;
  std::shared_ptr<IFunction> createFunction(const std::string &type) const;
 
  std::shared_ptr<IFunction> createInitialized(const std::string &input) const;
 
  std::shared_ptr<MultiDomainFunction> createInitializedMultiDomainFunction(const std::string &input,
                                                                            size_t domainNumber) const;
 
  template <typename FunctionType> std::vector<std::string> getFunctionNames() const;
  std::vector<std::string> getFunctionNamesGUI() const;
  // Unhide the base class version (to satisfy the intel compiler)
  using Kernel::DynamicFactory<IFunction>::subscribe;
  void subscribe(const std::string &className, std::unique_ptr<AbstractFactory> pAbstractFactory,
                 Kernel::DynamicFactory<IFunction>::SubscribeAction replace = ErrorIfExists);
 
  void unsubscribe(const std::string &className);
 
private:
  friend struct Mantid::Kernel::CreateUsingNew<FunctionFactoryImpl>;
 
  FunctionFactoryImpl();
  ~FunctionFactoryImpl() override = default;
  using Kernel::DynamicFactory<IFunction>::create;
  using Kernel::DynamicFactory<IFunction>::createUnwrapped;
 
  std::shared_ptr<IFunction> createSimple(const Expression &expr,
                                          std::map<std::string, std::string> &parentAttributes) const;
  std::shared_ptr<IPeakFunction> createPeakFunction(const Expression &expr, const std::string &name) const;
  std::shared_ptr<CompositeFunction> createComposite(const Expression &expr,
                                                     std::map<std::string, std::string> &parentAttributes) const;
 
  void inputError(const std::string &str = "") const;
  void addConstraints(const std::shared_ptr<IFunction> &fun, const Expression &expr) const;
  void addConstraint(const std::shared_ptr<IFunction> &fun, const Expression &expr) const;
  void addConstraint(const std::shared_ptr<IFunction> &fun, const Expression &constraint_expr,
                     const Expression &penalty_expr) const;
  void addTies(const std::shared_ptr<IFunction> &fun, const Expression &expr) const;
  void addTie(const std::shared_ptr<IFunction> &fun, const Expression &expr) const;
 
  mutable std::map<std::string, std::vector<std::string>> m_cachedFunctionNames;
  mutable std::mutex m_mutex;
};
 
template <typename FunctionType> std::vector<std::string> FunctionFactoryImpl::getFunctionNames() const {
  std::lock_guard<std::mutex> _lock(m_mutex);
 
  const std::string soughtType(typeid(FunctionType).name());
  if (m_cachedFunctionNames.find(soughtType) != m_cachedFunctionNames.end()) {
    return m_cachedFunctionNames[soughtType];
  }
 
  // Create the entry in the cache and work with it directly
  std::vector<std::string> &typeNames = m_cachedFunctionNames[soughtType];
  const std::vector<std::string> names = this->getKeys();
  std::copy_if(names.cbegin(), names.cend(), std::back_inserter(typeNames), [this](const std::string &name) {
    std::shared_ptr<IFunction> func = this->createFunction(name);
    return std::dynamic_pointer_cast<FunctionType>(func);
  });
  return typeNames;
}
 
using FunctionFactory = Mantid::Kernel::SingletonHolder<FunctionFactoryImpl>;
 
using FunctionFactoryUpdateNotification = FunctionFactoryImpl::UpdateNotification;
using FunctionFactoryUpdateNotification_ptr = const Poco::AutoPtr<FunctionFactoryUpdateNotification> &;
} // namespace API
} // namespace Mantid
 
namespace Mantid {
namespace Kernel {
EXTERN_MANTID_API template class MANTID_API_DLL Mantid::Kernel::SingletonHolder<Mantid::API::FunctionFactoryImpl>;
}
} // namespace Mantid
 
#define DECLARE_FUNCTION(classname)                                                                                    \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper                                                                                   \
      register_function_##classname(((Mantid::API::FunctionFactory::Instance().subscribe<classname>(#classname)), 0)); \
  }