WorkspaceFactory.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
 
/* Used to register classes into the factory. creates a global object in an
 * anonymous namespace. The object itself does nothing, but the comma operator
 * is used in the call to its constructor to effect a call to the factory's
 * subscribe method.
 */
#define DECLARE_WORKSPACE(classname)                                                                                   \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper                                                                                   \
      register_ws_##classname(((Mantid::API::WorkspaceFactory::Instance().subscribe<classname>(#classname)), 0));      \
  }
 
#include "MantidAPI/DllConfig.h"
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidAPI/Workspace_fwd.h"
#include "MantidKernel/DynamicFactory.h"
#include "MantidKernel/SingletonHolder.h"
 
#include <memory>
 
namespace Mantid {
namespace API {
class ITableWorkspace;
class IPeaksWorkspace;
class Workspace;
 
class MANTID_API_DLL WorkspaceFactoryImpl : public Kernel::DynamicFactory<Workspace> {
public:
  WorkspaceFactoryImpl(const WorkspaceFactoryImpl &) = delete;
  WorkspaceFactoryImpl &operator=(const WorkspaceFactoryImpl &) = delete;
  MatrixWorkspace_sptr create(const MatrixWorkspace_const_sptr &parent, size_t NVectors = size_t(-1),
                              size_t XLength = size_t(-1), size_t YLength = size_t(-1)) const;
  MatrixWorkspace_sptr create(const std::string &className, const size_t &NVectors, const size_t &XLength,
                              const size_t &YLength) const;
 
  void initializeFromParent(const MatrixWorkspace &parent, MatrixWorkspace &child, const bool differentSize) const;
 
  std::shared_ptr<ITableWorkspace> createTable(const std::string &className = "TableWorkspace") const;
 
  std::shared_ptr<IPeaksWorkspace> createPeaks(const std::string &className = "PeaksWorkspace") const;
 
private:
  friend struct Mantid::Kernel::CreateUsingNew<WorkspaceFactoryImpl>;
 
  WorkspaceFactoryImpl();
  ~WorkspaceFactoryImpl() override = default;
  // Unhide the inherited create method but make it private
  using Kernel::DynamicFactory<Workspace>::create;
};
 
using WorkspaceFactory = Mantid::Kernel::SingletonHolder<WorkspaceFactoryImpl>;
 
template <class T, class... InitArgs> std::shared_ptr<T> createWorkspace(InitArgs... args) {
  auto ws = std::make_shared<T>();
  ws->initialize(args...);
  return ws;
}
 
} // namespace API
} // namespace Mantid
 
namespace Mantid {
namespace Kernel {
EXTERN_MANTID_API template class MANTID_API_DLL Mantid::Kernel::SingletonHolder<Mantid::API::WorkspaceFactoryImpl>;
}
} // namespace Mantid