UserInputValidator.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidQtWidgets/Common/UserInputValidator.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/WorkspaceGroup.h"
#include "MantidQtWidgets/Common/WorkspaceUtils.h"
 
#include <QLabel>
#include <QLineEdit>
#include <QString>
#include <QValidator>
 
#include <algorithm>
#include <cmath>
 
using namespace Mantid::API;
using namespace MantidQt::MantidWidgets;
 
namespace // anonymous
{
template <typename T> void sortPair(std::pair<T, T> &pair) {
  if (pair.first > pair.second) {
    T temp = pair.first;
    pair.first = pair.second;
    pair.second = temp;
  }
}
 
bool doesExistInADS(std::string const &workspaceName) {
  return AnalysisDataService::Instance().doesExist(workspaceName);
}
 
std::optional<std::string> containsInvalidWorkspace(const WorkspaceGroup_const_sptr &group) {
  if (group->isEmpty())
    return "The group workspace " + group->getName() + " is empty.";
 
  const auto it =
      std::find_if(std::cbegin(*group), std::cend(*group), [](const auto &workspace) { return !workspace; });
  if (it != std::cend(*group))
    return "The group workspace " + group->getName() + " contains an invalid workspace.";
  return std::nullopt;
}
 
} // anonymous namespace
 
namespace MantidQt::CustomInterfaces {
UserInputValidator::UserInputValidator() : m_errorMessages(), m_error(false) {}
 
UserInputValidator::~UserInputValidator() = default;
 
bool UserInputValidator::checkFieldIsNotEmpty(const QString &name, QLineEdit *field, QLabel *errorLabel) {
  if (field->text().trimmed().isEmpty()) {
    setErrorLabel(errorLabel, false);
    addErrorMessage(name.toStdString() + " has been left blank.");
    return false;
  } else {
    setErrorLabel(errorLabel, true);
    return true;
  }
}
 
bool UserInputValidator::checkFieldIsValid(const QString &errorMessage, QLineEdit *field, QLabel *errorLabel) {
  int dummyPos = 0;
  QString text = field->text();
  QValidator::State fieldState = field->validator()->validate(text, dummyPos);
 
  if (fieldState == QValidator::Acceptable) {
    setErrorLabel(errorLabel, true);
    return true;
  } else {
    setErrorLabel(errorLabel, false);
    addErrorMessage(errorMessage.toStdString());
    return false;
  }
}
 
bool UserInputValidator::checkWorkspaceSelectorIsNotEmpty(const QString &name, WorkspaceSelector *workspaceSelector) {
  if (workspaceSelector->currentText() == "") {
    addErrorMessage("No " + name.toStdString() + " workspace has been selected.");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkFileFinderWidgetIsValid(const QString &name, const FileFinderWidget *widget) {
  if (!widget->isValid()) {
    addErrorMessage(name.toStdString() + " file error: " + widget->getFileProblem().toStdString());
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkDataSelectorIsValid(const QString &name, DataSelector *widget, bool const silent,
                                                  bool const autoLoad) {
  if (!widget->isValid(autoLoad)) {
    addErrorMessage(name.toStdString() + " error: " + widget->getProblem().toStdString(), silent);
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkValidRange(const QString &name, std::pair<double, double> range) {
  if (range.second == range.first) {
    addErrorMessage(name.toStdString() + " must have a non-zero width.");
    return false;
  }
 
  if (range.second < range.first) {
    addErrorMessage("The start of " + name.toStdString() + " must be less than the end.");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkRangesDontOverlap(std::pair<double, double> rangeA, std::pair<double, double> rangeB) {
  sortPair(rangeA);
  sortPair(rangeB);
 
  if (!(rangeA.second < rangeB.first || rangeB.second < rangeA.first)) {
    QString message = QString("The ranges must not overlap: [%1,%2], [%3,%4].")
                          .arg(rangeA.first)
                          .arg(rangeA.second)
                          .arg(rangeB.first)
                          .arg(rangeB.second);
    addErrorMessage(message.toStdString());
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkRangeIsEnclosed(const QString &outerName, std::pair<double, double> outer,
                                              const QString &innerName, std::pair<double, double> inner) {
  sortPair(inner);
  sortPair(outer);
 
  if (inner.first < outer.first || inner.second > outer.second) {
    addErrorMessage(outerName.toStdString() + " must completely enclose " + innerName.toStdString() + ".");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkBins(double lower, double binWidth, double upper, double tolerance) {
  double range = upper - lower;
  if (range < 0) {
    addErrorMessage("The start of a binning range must be less than the end.");
    return false;
  }
  if (range == 0) {
    addErrorMessage("Binning ranges must be non-zero.");
    return false;
  }
  if (binWidth == 0) {
    addErrorMessage("Bin width must be non-zero.");
    return false;
  }
  if (binWidth < 0) {
    addErrorMessage("Bin width must be a positive value.");
    return false;
  }
 
  while (range > tolerance)
    range -= binWidth;
 
  if (std::abs(range) > tolerance) {
    addErrorMessage("Bin width must allow for even splitting of the range.");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkNotEqual(const QString &name, double x, double y, double tolerance) {
  double delta = x - y;
 
  if (std::abs(delta) <= tolerance) {
    std::stringstream msg;
    msg << name.toStdString() << " (" << x << ")"
        << " should not be equal to " << y << ".";
    addErrorMessage(msg.str());
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkWorkspaceExists(QString const &workspaceName, bool silent) {
  if (workspaceName.isEmpty()) {
    addErrorMessage("No workspace added.", silent);
    return false;
  }
 
  if (!doesExistInADS(workspaceName.toStdString())) {
    addErrorMessage(workspaceName.toStdString() + " not found.", silent);
    return false;
  }
  return true;
}
 
bool UserInputValidator::checkWorkspaceNumberOfHistograms(QString const &workspaceName, std::size_t const &validSize) {
  if (checkWorkspaceExists(workspaceName))
    return checkWorkspaceNumberOfHistograms(WorkspaceUtils::getADSWorkspace(workspaceName.toStdString()), validSize);
  return false;
}
 
bool UserInputValidator::checkWorkspaceNumberOfHistograms(const MatrixWorkspace_sptr &workspace,
                                                          std::size_t const &validSize) {
  if (workspace->getNumberHistograms() != validSize) {
    addErrorMessage(workspace->getName() + " should contain " + std::to_string(validSize) + " spectra.");
    return false;
  }
  return true;
}
 
bool UserInputValidator::checkWorkspaceNumberOfBins(QString const &workspaceName, std::size_t const &validSize) {
  if (checkWorkspaceExists(workspaceName))
    return checkWorkspaceNumberOfBins(WorkspaceUtils::getADSWorkspace(workspaceName.toStdString()), validSize);
  return false;
}
 
bool UserInputValidator::checkWorkspaceNumberOfBins(const MatrixWorkspace_sptr &workspace,
                                                    std::size_t const &validSize) {
  if (workspace->x(0).size() != validSize) {
    addErrorMessage(workspace->getName() + " should contain " + std::to_string(validSize) + " bins.");
    return false;
  }
  return true;
}
 
bool UserInputValidator::checkWorkspaceGroupIsValid(QString const &groupName, QString const &inputType, bool silent) {
  if (checkWorkspaceType<WorkspaceGroup>(groupName, inputType, "WorkspaceGroup", silent)) {
    if (auto const group = WorkspaceUtils::getADSWorkspace<WorkspaceGroup>(groupName.toStdString())) {
      if (auto const error = containsInvalidWorkspace(group)) {
        addErrorMessage(error.value(), silent);
        return false;
      }
      return true;
    }
  }
  return false;
}
 
void UserInputValidator::addErrorMessage(const std::string &message, bool const silent) {
  if (!silent && !m_errorMessages.contains(QString::fromStdString(message)))
    m_errorMessages.append(QString::fromStdString(message));
  m_error = true;
}
 
std::string UserInputValidator::generateErrorMessage() const {
  if (m_errorMessages.isEmpty())
    return "";
 
  return "Please correct the following:\n" + m_errorMessages.join("\n").toStdString();
}
 
bool UserInputValidator::isAllInputValid() const { return !m_error; }
 
void UserInputValidator::setErrorLabel(QLabel *errorLabel, bool valid) {
  // Do nothing if no error label was provided
  if (errorLabel == nullptr)
    return;
 
  if (!valid) {
    // Set the label to be red
    QPalette palette = errorLabel->palette();
    palette.setColor(errorLabel->foregroundRole(), Qt::red);
    errorLabel->setPalette(palette);
 
    errorLabel->setText("*");
  } else {
    errorLabel->setText("");
  }
 
  // Only show the label if input is invalid
  errorLabel->setVisible(!valid);
}
} // namespace MantidQt::CustomInterfaces