Calculator.h

Go to the documentation of this file.

#ifndef CORE_CALCULATOR_H_
#define CORE_CALCULATOR_H_
/* Internal Includes */
#include "Core/BaseClasses/ObjectWithLog.h"
#include "Core/BaseClasses/ObjectWithStructure.h"
#include "Core/BaseClasses/StateHandableObject.h"
/* External Includes */
#include <string>

namespace Scine {

namespace Utils {
class Results;
class Settings;
class StatesHandler;
class PropertyList;
} // namespace Utils

namespace Core {
class Calculator : public StateHandableObject, public ObjectWithStructure, public ObjectWithLog {
 public:
  static constexpr const char* interface = "calculator";

  Calculator() = default;
  virtual ~Calculator() = default;
  virtual void setRequiredProperties(const Utils::PropertyList& requiredProperties) = 0;
  virtual Utils::PropertyList getRequiredProperties() const = 0;
  virtual Utils::PropertyList possibleProperties() const = 0;
  virtual const Utils::Results& calculate(std::string description = "") = 0;
  virtual std::string name() const = 0;
  std::unique_ptr<Core::Calculator> clone() const {
    return std::unique_ptr<Core::Calculator>(this->cloneImpl());
  }
  virtual Utils::Settings& settings() = 0;
  virtual const Utils::Settings& settings() const = 0;
  virtual Utils::Results& results() = 0;
  virtual const Utils::Results& results() const = 0;
  virtual bool supportsMethodFamily(const std::string& methodFamily) const = 0;
  static auto supports(const std::string& methodFamily) {
    return [methodFamily](const std::shared_ptr<Calculator>& calculatorPtr) -> bool {
      return calculatorPtr->supportsMethodFamily(methodFamily);
    };
  }

 private:
  /*
   * Implementation of the clone() function, pure virtual private method.
   * It returns a pointer to allow for covariant return types in inheritance.
   */
  virtual Core::Calculator* cloneImpl() const = 0;
};

} /* namespace Core */
} /* namespace Scine */

#endif /* CORE_CALCULATOR_H_ */