UserInputValidator.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/MatrixWorkspace_fwd.h"
#include "MantidQtWidgets/Common/DataSelector.h"
#include "MantidQtWidgets/Common/FileFinderWidget.h"
#include "MantidQtWidgets/Common/WorkspaceSelector.h"
 
using MantidQt::API::FileFinderWidget;
using MantidQt::MantidWidgets::DataSelector;
using MantidQt::MantidWidgets::WorkspaceSelector;
 
class QLineEdit;
class QLabel;
class QString;
class QStringList;
 
namespace MantidQt {
namespace CustomInterfaces {
class DLLExport UserInputValidator {
public:
  UserInputValidator();
 
  bool checkFieldIsNotEmpty(const QString &name, QLineEdit *field, QLabel *errorLabel = nullptr);
  bool checkFieldIsValid(const QString &errorMessage, QLineEdit *field, QLabel *errorLabel = nullptr);
  bool checkWorkspaceSelectorIsNotEmpty(const QString &name, WorkspaceSelector *workspaceSelector);
  bool checkFileFinderWidgetIsValid(const QString &name, FileFinderWidget *widget);
  bool checkDataSelectorIsValid(const QString &name, DataSelector *widget, bool silent = false);
  bool checkValidRange(const QString &name, std::pair<double, double> range);
  bool checkRangesDontOverlap(std::pair<double, double> rangeA, std::pair<double, double> rangeB);
  bool checkRangeIsEnclosed(const QString &outerName, std::pair<double, double> outer, const QString &innerName,
                            std::pair<double, double> inner);
  bool checkBins(double lower, double binWidth, double upper, double tolerance = 0.00000001);
  bool checkNotEqual(const QString &name, double x, double y = 0.0, double tolerance = 0.00000001);
 
  template <typename T = Mantid::API::MatrixWorkspace>
  bool checkWorkspaceType(QString const &workspaceName, QString const &inputType, QString const &validType,
                          bool silent = false);
  bool checkWorkspaceExists(QString const &workspaceName, bool silent = false);
  bool checkWorkspaceNumberOfHistograms(QString const &workspaceName, std::size_t const &validSize);
  bool checkWorkspaceNumberOfHistograms(const Mantid::API::MatrixWorkspace_sptr &, std::size_t const &validSize);
  bool checkWorkspaceNumberOfBins(QString const &workspaceName, std::size_t const &validSize);
  bool checkWorkspaceNumberOfBins(const Mantid::API::MatrixWorkspace_sptr &, std::size_t const &validSize);
  bool checkWorkspaceGroupIsValid(QString const &groupName, QString const &inputType, bool silent = false);
 
  void addErrorMessage(const QString &message, bool silent = false);
 
  void setErrorLabel(QLabel *errorLabel, bool valid);
 
  QString generateErrorMessage();
  bool isAllInputValid();
 
private:
  template <typename T = Mantid::API::MatrixWorkspace>
  std::shared_ptr<T> getADSWorkspace(std::string const &workspaceName);
 
  QStringList m_errorMessages;
  bool m_error;
};
 
template <typename T>
bool UserInputValidator::checkWorkspaceType(QString const &workspaceName, QString const &inputType,
                                            QString const &validType, bool silent) {
  if (checkWorkspaceExists(workspaceName, silent)) {
    if (!getADSWorkspace<T>(workspaceName.toStdString())) {
      addErrorMessage("The " + inputType + " workspace is not a " + validType + ".", silent);
      return false;
    } else
      return true;
  }
  return false;
}
 
template <typename T> std::shared_ptr<T> UserInputValidator::getADSWorkspace(std::string const &workspaceName) {
  return Mantid::API::AnalysisDataService::Instance().retrieveWS<T>(workspaceName);
}
 
} // namespace CustomInterfaces
} // namespace MantidQt