ArrayLengthValidator.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 "MantidKernel/ArrayLengthValidator.h"
 
#include <cstdint>
#include <memory>
 
using namespace Mantid::Kernel;
 
namespace Mantid::Kernel {
 
//----------------------------------------------------------------------------------------------
template <typename TYPE>
ArrayLengthValidator<TYPE>::ArrayLengthValidator()
    : TypedValidator<std::vector<TYPE>>(), m_arraySize(size_t(0)), m_hasArraySize(false), m_arraySizeMin(size_t(0)),
      m_hasArraySizeMin(false), m_arraySizeMax(size_t(0)), m_hasArraySizeMax(false) {}
//----------------------------------------------------------------------------------------------
template <typename TYPE>
ArrayLengthValidator<TYPE>::ArrayLengthValidator(const size_t len)
    : TypedValidator<std::vector<TYPE>>(), m_arraySize(size_t(len)), m_hasArraySize(true), m_arraySizeMin(size_t(0)),
      m_hasArraySizeMin(false), m_arraySizeMax(size_t(0)), m_hasArraySizeMax(false) {}
//----------------------------------------------------------------------------------------------
template <typename TYPE>
ArrayLengthValidator<TYPE>::ArrayLengthValidator(const size_t lenmin, const size_t lenmax)
    : TypedValidator<std::vector<TYPE>>(), m_arraySize(size_t(0)), m_hasArraySize(false),
      m_arraySizeMin(size_t(lenmin)), m_hasArraySizeMin(true), m_arraySizeMax(size_t(lenmax)), m_hasArraySizeMax(true) {
}
//----------------------------------------------------------------------------------------------
template <typename TYPE> ArrayLengthValidator<TYPE>::~ArrayLengthValidator() = default;
 
template <typename TYPE> bool ArrayLengthValidator<TYPE>::hasLength() const { return this->m_hasArraySize; }
 
template <typename TYPE> bool ArrayLengthValidator<TYPE>::hasMinLength() const { return this->m_hasArraySizeMin; }
 
template <typename TYPE> bool ArrayLengthValidator<TYPE>::hasMaxLength() const { return this->m_hasArraySizeMax; }
 
template <typename TYPE> const size_t &ArrayLengthValidator<TYPE>::getLength() const { return this->m_arraySize; }
 
template <typename TYPE> const size_t &ArrayLengthValidator<TYPE>::getMinLength() const { return this->m_arraySizeMin; }
 
template <typename TYPE> const size_t &ArrayLengthValidator<TYPE>::getMaxLength() const { return this->m_arraySizeMax; }
 
template <typename TYPE> void ArrayLengthValidator<TYPE>::setLength(const size_t &value) {
  this->m_hasArraySize = true;
  this->m_arraySize = value;
  this->clearLengthMax();
  this->clearLengthMin();
}
 
template <typename TYPE> void ArrayLengthValidator<TYPE>::setLengthMin(const size_t &value) {
  this->m_hasArraySizeMin = true;
  this->m_arraySizeMin = value;
  this->clearLength();
}
template <typename TYPE> void ArrayLengthValidator<TYPE>::setLengthMax(const size_t &value) {
  this->m_hasArraySizeMax = true;
  this->m_arraySizeMax = value;
  this->clearLength();
}
 
template <typename TYPE> void ArrayLengthValidator<TYPE>::clearLength() {
  this->m_hasArraySize = false;
  this->m_arraySize = size_t(0);
}
 
template <typename TYPE> void ArrayLengthValidator<TYPE>::clearLengthMin() {
  this->m_hasArraySizeMin = false;
  this->m_arraySizeMin = size_t(0);
}
 
template <typename TYPE> void ArrayLengthValidator<TYPE>::clearLengthMax() {
  this->m_hasArraySizeMax = false;
  this->m_arraySizeMax = size_t(0);
}
 
template <typename TYPE> IValidator_sptr ArrayLengthValidator<TYPE>::clone() const {
  return std::make_shared<ArrayLengthValidator>(*this);
}
 
template <typename TYPE> std::string ArrayLengthValidator<TYPE>::checkValidity(const std::vector<TYPE> &value) const {
  if (this->hasLength() && value.size() != this->m_arraySize) {
    return "Incorrect size";
  }
  if (this->hasMinLength() && value.size() < this->m_arraySizeMin) {
    return "Array size too short";
  }
  if (this->hasMaxLength() && value.size() > this->m_arraySizeMax) {
    return "Array size too long";
  }
  return "";
}
 
// Required explicit instantiations
template class ArrayLengthValidator<double>;
template class ArrayLengthValidator<int32_t>;
template class ArrayLengthValidator<int64_t>;
template class ArrayLengthValidator<std::string>;
#if defined(_WIN32) || defined(__clang__) && defined(__APPLE__)
template class ArrayLengthValidator<long>;
#endif
} // namespace Mantid::Kernel