AlgorithmProxy.h

// 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/IAlgorithm.h"
#include "MantidKernel/PropertyManagerOwner.h"

#ifdef _MSC_VER
#pragma warning(disable : 4250) // Disable warning regarding inheritance via
                                // dominance, we have no way around it with the
                                // design
#endif

//----------------------------------------------------------------------
// Forward Declaration
//----------------------------------------------------------------------
namespace Poco {
template <class R, class A, class O, class S> class ActiveMethod;
template <class O> class ActiveStarter;
class Void;
} // namespace Poco

namespace Mantid {
namespace API {
class Algorithm;
using Algorithm_sptr = boost::shared_ptr<Algorithm>;

/**

A proxy class that stands between the user and the actual algorithm.
AlgorithmDataService stores algoruithm proxies. Actual algorithms are
created by the proxy and destroyed after execution to free memory.
Algorithm and its proxy share all properties.

@author Russell Taylor, Tessella Support Services plc
@author Based on the Gaudi class of the same name (see
http://proj-gaudi.web.cern.ch/proj-gaudi/)
@date 12/09/2007
@author Roman Tolchenov, Tessella plc
@date 03/03/2009
*/
class MANTID_API_DLL AlgorithmProxy : public IAlgorithm,
                                      public Kernel::PropertyManagerOwner {
public:
  AlgorithmProxy(const Algorithm_sptr &alg);
  AlgorithmProxy(const AlgorithmProxy &) = delete;
  AlgorithmProxy &operator=(const AlgorithmProxy &) = delete;
  ~AlgorithmProxy() override;

  /// The name of the algorithm
  const std::string name() const override { return m_name; }
  /// The version of the algorithm
  int version() const override { return m_version; }
  /// The category of the algorithm
  const std::string category() const override { return m_category; }
  /// Function to return all of the categories that contain this algorithm
  const std::vector<std::string> categories() const override;
  /// Function to return the seperator token for the category string. A default
  /// implementation ',' is provided
  const std::string categorySeparator() const override {
    return m_categorySeparator;
  }
  /// Function to return all of the seeAlso algorithms related to this algorithm
  const std::vector<std::string> seeAlso() const override { return m_seeAlso; };
  /// Aliases to the algorithm
  const std::string alias() const override { return m_alias; }
  /// Optional documentation URL for the real algorithm
  const std::string helpURL() const override { return m_helpURL; }
  /// function returns a summary message that will be displayed in the default
  /// GUI, and in the help.
  const std::string summary() const override { return m_summary; }

  /// The algorithmID
  AlgorithmID getAlgorithmID() const override;

  void initialize() override;
  std::map<std::string, std::string> validateInputs() override;
  bool execute() override;
  void executeAsChildAlg() override {
    throw std::runtime_error("Not implemented.");
  }
  Poco::ActiveResult<bool> executeAsync() override;

  /// Gets the current execution state
  ExecutionState executionState() const override;
  /// Gets the current result State
  ResultState resultState() const override;

  bool isInitialized() const override;
  bool isExecuted() const override;

  /// To query whether algorithm is a child. A proxy is always at top level,
  /// returns false
  bool isChild() const override { return m_isChild; }
  void setChild(const bool val) override {
    m_isChild = val;
    setAlwaysStoreInADS(!val);
  }
  void setAlwaysStoreInADS(const bool val) override {
    m_setAlwaysStoreInADS = val;
  }
  bool getAlwaysStoreInADS() const override { return m_setAlwaysStoreInADS; }

  /// Proxies only manage parent algorithms
  void enableHistoryRecordingForChild(const bool) override{};
  void setRethrows(const bool rethrow) override;

  const std::string workspaceMethodName() const override;
  const std::vector<std::string> workspaceMethodOn() const override;
  const std::string workspaceMethodInputProperty() const override;

  /** @name PropertyManager methods */
  //@{
  /// Set the property value
  void setPropertyValue(const std::string &name,
                        const std::string &value) override;
  /// Do something after a property was set
  void afterPropertySet(const std::string &) override;
  /// Make m_properties point to the same PropertyManager as po.
  void copyPropertiesFrom(const PropertyManagerOwner &po) override;
  //@}

  void cancel() override;
  bool isRunning() const override;

  void addObserver(const Poco::AbstractObserver &observer) const override;
  void removeObserver(const Poco::AbstractObserver &observer) const override;

  /// Set logging on or off
  ///@param value :: true = logging enabled
  void setLogging(const bool value) override { m_isLoggingEnabled = value; }
  /// Is the algorithm have logging enabled
  bool isLogging() const override { return m_isLoggingEnabled; }

  /// returns the logging priority offset
  void setLoggingOffset(const int value) override { m_loggingOffset = value; }
  /// returns the logging priority offset
  int getLoggingOffset() const override { return m_loggingOffset; }
  /// disable Logging of start and end messages
  void setAlgStartupLogging(const bool enabled) override;
  /// get the state of Logging of start and end messages
  bool getAlgStartupLogging() const override;

  /// setting the child start progress
  void setChildStartProgress(const double startProgress) const override;
  /// setting the child end progress
  void setChildEndProgress(const double endProgress) const override;

  /** @name Serialization */
  //@{
  /// Serialize an object to a string
  std::string toString() const override;
  /// Serialize as a json value
  Json::Value toJson() const override;
  //@}

private:
  void createConcreteAlg(bool initOnly = false);
  void stopped();
  void addObservers();
  void dropWorkspaceReferences();

  /// Poco::ActiveMethod used to implement asynchronous execution.
  Poco::ActiveMethod<bool, Poco::Void, AlgorithmProxy,
                     Poco::ActiveStarter<AlgorithmProxy>> *m_executeAsync;
  /// Execute asynchronous implementation
  bool executeAsyncImpl(const Poco::Void &dummy);

  const std::string m_name;     ///< name of the real algorithm
  const std::string m_category; ///< category of the real algorithm
  const std::string
      m_categorySeparator; ///< category seperator of the real algorithm
  const std::vector<std::string> m_seeAlso; ///< seeAlso of the real algorithm
  const std::string m_alias;                ///< alias to the algorithm
  const std::string m_helpURL;              ///< Optional documentation URL
  const std::string m_summary; ///< Message to display in GUI and help.
  const int m_version;         ///< version of the real algorithm

  mutable boost::shared_ptr<Algorithm>
      m_alg; ///< Shared pointer to a real algorithm. Created on demand

  ExecutionState m_executionState; ///< the current execution state
  ResultState m_resultState;       ///< the current result State
  bool m_isLoggingEnabled; ///< is the logging of the underlying algorithm
                           /// enabled
  int m_loggingOffset;     ///< the logging priority offset
  bool m_isAlgStartupLoggingEnabled; /// Whether to log alg startup and
                                     /// closedown messages from the base class
                                     /// (default = true)
  bool m_rethrow;                    ///< Whether or not to rethrow exceptions.
  bool m_isChild;                    ///< Is this a child algo
  bool m_setAlwaysStoreInADS;        ///< If this will save in ADS

  /// Temporary holder of external observers wishing to subscribe
  mutable std::vector<const Poco::AbstractObserver *> m_externalObservers;
};

} // namespace API
} // namespace Mantid