BoundedValidator.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 "MantidKernel/TypedValidator.h"
#include <memory>
#include <sstream>
#include <string>
 
namespace Mantid {
namespace Kernel {
namespace {
constexpr int LOWER_BOUND = -1;
constexpr int UPPER_BOUND = 1;
} // namespace
 
template <class TYPE> class DLLExport BoundedValidator final : public TypedValidator<TYPE> {
public:
  BoundedValidator() noexcept
      : TypedValidator<TYPE>(), m_hasLowerBound(false), m_hasUpperBound(false), m_lowerExclusive(false),
        m_upperExclusive(false), m_lowerBound(TYPE()), m_upperBound(TYPE()), m_hasError(false) {}
 
  BoundedValidator(const TYPE &lowerBound, const TYPE &upperBound, bool exclusive = false) noexcept
      : TypedValidator<TYPE>(), m_hasLowerBound(true), m_hasUpperBound(true), m_lowerExclusive(exclusive),
        m_upperExclusive(exclusive), m_lowerBound(lowerBound), m_upperBound(upperBound), m_hasError(false) {}
 
  bool hasLower() const noexcept { return m_hasLowerBound; }
  bool hasUpper() const noexcept { return m_hasUpperBound; }
  TYPE lower() const noexcept { return m_lowerBound; }
  TYPE upper() const noexcept { return m_upperBound; }
  bool isLowerExclusive() const noexcept { return m_lowerExclusive; }
  bool isUpperExclusive() const noexcept { return m_upperExclusive; }
  void setLowerExclusive(const bool exclusive) noexcept { m_lowerExclusive = exclusive; }
  void setUpperExclusive(const bool exclusive) noexcept { m_upperExclusive = exclusive; }
 
  void setExclusive(const bool exclusive) noexcept {
    setLowerExclusive(exclusive);
    setUpperExclusive(exclusive);
  }
 
  void setLower(const TYPE &value) noexcept {
    m_hasLowerBound = true;
    m_lowerBound = value;
  }
 
  void setUpper(const TYPE &value) noexcept {
    m_hasUpperBound = true;
    m_upperBound = value;
  }
 
  void clearLower() noexcept {
    m_hasLowerBound = false;
    m_lowerBound = TYPE();
  }
  void clearUpper() noexcept {
    m_hasUpperBound = false;
    m_upperBound = TYPE();
  }
 
  void setBounds(const TYPE &lower, const TYPE &upper) noexcept {
    setLower(lower);
    setUpper(upper);
  }
 
  void clearBounds() noexcept {
    clearLower();
    clearUpper();
  }
 
  void setError(const TYPE &value) {
    m_error = value;
    m_hasError = true;
  }
 
  IValidator_sptr clone() const override { return std::make_shared<BoundedValidator>(*this); }
 
private:
  // Data and Function Members for This Class Implementation.
 
  bool m_hasLowerBound;
  bool m_hasUpperBound;
  bool m_lowerExclusive;
  bool m_upperExclusive;
  TYPE m_lowerBound;
  TYPE m_upperBound;
  TYPE m_error;
  bool m_hasError;
 
  std::string checkValidity(const TYPE &value) const override {
    // declare a class that can do conversions to string
    std::ostringstream error;
    // load in the "no error" condition
    error << "";
    // it is allowed not to have a lower bound, if not then you don't need to
    // check
    if (m_hasLowerBound && (value < (errorAdjustment(m_lowerBound, LOWER_BOUND)) ||
                            (value == (errorAdjustment(m_lowerBound, LOWER_BOUND)) && m_lowerExclusive))) {
      error << "Selected value " << value << " is ";
      (m_lowerExclusive) ? error << "<=" : error << "<";
      error << " the lower bound (" << m_lowerBound;
      (error.str() != "" && m_hasError) ? error << " +/- " << m_error << ")" : error << ")";
    }
 
    if (m_hasUpperBound && (value > (errorAdjustment(m_upperBound, UPPER_BOUND)) ||
                            (value == (errorAdjustment(m_upperBound, UPPER_BOUND)) && m_upperExclusive))) {
      error << "Selected value " << value << " is ";
      (m_upperExclusive) ? error << ">=" : error << ">";
      error << " the upper bound (" << m_upperBound;
      (error.str() != "" && m_hasError) ? error << " +/- " << m_error << ")" : error << ")";
    }
    return error.str();
  }
 
  TYPE errorAdjustment(const TYPE &boundingValue, const int boundID) const {
    (void)boundID; // avoid unused variable warning.
    return boundingValue;
  }
};
 
template <> inline void BoundedValidator<std::string>::setError(const std::string &value) {
  (void)value; // avoid unused variable warning.
  throw std::invalid_argument("BoundedValidator<std::string> does not support error.");
}
template <>
inline double BoundedValidator<double>::errorAdjustment(const double &boundingValue, const int boundID) const {
  double adjValue;
  m_hasError ? adjValue = boundingValue + m_error *boundID : adjValue = boundingValue;
  return adjValue;
}
template <> inline int BoundedValidator<int>::errorAdjustment(const int &boundingValue, const int boundID) const {
  int adjValue;
  m_hasError ? adjValue = boundingValue + m_error *boundID : adjValue = boundingValue;
  return adjValue;
}
 
} // namespace Kernel
} // namespace Mantid