WorkspaceProperty.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
 
#include "MantidAPI/IWorkspaceProperty.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/PropertyWithValue.h"
 
#include <string>
 
namespace Mantid {
namespace API {
// -------------------------------------------------------------------------
// Forward decaration
// -------------------------------------------------------------------------
class MatrixWorkspace;
class WorkspaceGroup;
 
struct PropertyMode {
  enum Type { Mandatory, Optional };
};
struct LockMode {
  enum Type { Lock, NoLock };
};
 
template <typename TYPE = MatrixWorkspace>
class WorkspaceProperty : public Kernel::PropertyWithValue<std::shared_ptr<TYPE>>, public IWorkspaceProperty {
public:
  explicit WorkspaceProperty(
      const std::string &name, const std::string &wsName, const unsigned int direction,
      const Kernel::IValidator_sptr &validator = Kernel::IValidator_sptr(new Kernel::NullValidator));
 
  explicit WorkspaceProperty(
      const std::string &name, const std::string &wsName, const unsigned int direction,
      const PropertyMode::Type optional,
      const Kernel::IValidator_sptr &validator = Kernel::IValidator_sptr(new Kernel::NullValidator));
 
  explicit WorkspaceProperty(
      const std::string &name, const std::string &wsName, const unsigned int direction,
      const PropertyMode::Type optional, const LockMode::Type locking,
      const Kernel::IValidator_sptr &validator = Kernel::IValidator_sptr(new Kernel::NullValidator));
 
  WorkspaceProperty(const WorkspaceProperty &right);
 
  WorkspaceProperty &operator=(const WorkspaceProperty &right);
 
  WorkspaceProperty &operator=(const std::shared_ptr<TYPE> &value) override;
 
  WorkspaceProperty &operator+=(Kernel::Property const *) override;
 
  WorkspaceProperty<TYPE> *clone() const override;
 
  std::string value() const override;
 
  Json::Value valueAsJson() const override;
 
  bool isValueSerializable() const override;
 
  std::string getDefault() const override;
 
  std::string setValue(const std::string &value) override;
 
  std::string setValueFromJson(const Json::Value &value) override;
 
  std::string setDataItem(const std::shared_ptr<Kernel::DataItem> &value) override;
 
  std::string isValid() const override;
 
  bool isDefault() const override;
 
  bool isOptional() const override;
  bool isLocking() const override;
 
  std::vector<std::string> allowedValues() const override;
 
  const Kernel::PropertyHistory createHistory() const override;
 
  bool store() override;
 
  Workspace_sptr getWorkspace() const override;
 
  void setIsMasterRank(bool isMasterRank) override;
 
private:
  std::string isValidGroup(const std::shared_ptr<WorkspaceGroup> &wsGroup) const;
 
  std::string isValidOutputWs() const;
 
  std::string isOptionalWs() const;
 
  void clear() override;
 
  void retrieveWorkspaceFromADS();
 
  std::string m_workspaceName;
  std::string m_initialWSName;
  PropertyMode::Type m_optional;
  LockMode::Type m_locking;
 
  static Kernel::Logger g_log;
 
  bool m_isMasterRank{true};
};
 
template <typename TYPE> Kernel::Logger WorkspaceProperty<TYPE>::g_log("WorkspaceProperty");
 
} // namespace API
} // namespace Mantid