ArrayLengthValidator.cpp

#include "MantidKernel/ArrayLengthValidator.h"

#include <boost/make_shared.hpp>
#include <cstdint>

using namespace Mantid::Kernel;

namespace Mantid {
namespace Kernel {

//----------------------------------------------------------------------------------------------
/** No arg constructor
 */
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) {}
//----------------------------------------------------------------------------------------------
/** Constructor
 * @param len:: the legth of the array
 */
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) {}
//----------------------------------------------------------------------------------------------
/** Constructor
 * @param lenmin:: the minimum legth of the array
 * @param lenmax:: the maximum legth of the array
 */
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) {}
//----------------------------------------------------------------------------------------------
/** Destructor
 */
template <typename TYPE> ArrayLengthValidator<TYPE>::~ArrayLengthValidator() {}

/**
  Check if length is set
  @returns true/false
 */
template <typename TYPE> bool ArrayLengthValidator<TYPE>::hasLength() const {
  return this->m_hasArraySize;
}

/**
  Check if minimum length is set
  @returns true/false
 */
template <typename TYPE> bool ArrayLengthValidator<TYPE>::hasMinLength() const {
  return this->m_hasArraySizeMin;
}

/**
  Check if maximum length is set
  @returns true/false
 */
template <typename TYPE> bool ArrayLengthValidator<TYPE>::hasMaxLength() const {
  return this->m_hasArraySizeMax;
}

/**
  Function to retun the set length
  @returns  m_arraySize
 */
template <typename TYPE>
const size_t &ArrayLengthValidator<TYPE>::getLength() const {
  return this->m_arraySize;
}

/**
  Function to retun the set minimum length
  @returns  m_arraySize
 */
template <typename TYPE>
const size_t &ArrayLengthValidator<TYPE>::getMinLength() const {
  return this->m_arraySizeMin;
}

/**
  Function to retun the set maximum length
  @returns  m_arraySize
 */
template <typename TYPE>
const size_t &ArrayLengthValidator<TYPE>::getMaxLength() const {
  return this->m_arraySizeMax;
}

/**
  Function to set the length. It will automatically clear the minimum and
  maximum
  @param  value:: size_t type
 */
template <typename TYPE>
void ArrayLengthValidator<TYPE>::setLength(const size_t &value) {
  this->m_hasArraySize = true;
  this->m_arraySize = value;
  this->clearLengthMax();
  this->clearLengthMin();
}

/**
  Function to set the minimum length. It will automatically clear the set length
  @param  value:: size_t type
 */
template <typename TYPE>
void ArrayLengthValidator<TYPE>::setLengthMin(const size_t &value) {
  this->m_hasArraySizeMin = true;
  this->m_arraySizeMin = value;
  this->clearLength();
}
/**
  Function to set the maximum length. It will automatically clear the set length
  @param  value:: size_t type
 */
template <typename TYPE>
void ArrayLengthValidator<TYPE>::setLengthMax(const size_t &value) {
  this->m_hasArraySizeMax = true;
  this->m_arraySizeMax = value;
  this->clearLength();
}

/**
  Function to unset the length. It sets  m_hasArraySize to false, and the
  m_arraySize to 0
 */
template <typename TYPE> void ArrayLengthValidator<TYPE>::clearLength() {
  this->m_hasArraySize = false;
  this->m_arraySize = size_t(0);
}

/**
  Function to unset the minimum length. It sets  m_hasArraySizeMin to false, and
  the m_arraySizeMin to 0
 */
template <typename TYPE> void ArrayLengthValidator<TYPE>::clearLengthMin() {
  this->m_hasArraySizeMin = false;
  this->m_arraySizeMin = size_t(0);
}

/**
  Function to unset the maximum length. It sets  m_hasArraySizeMax to false, and
  the m_arraySizeMax to 0
 */
template <typename TYPE> void ArrayLengthValidator<TYPE>::clearLengthMax() {
  this->m_hasArraySizeMax = false;
  this->m_arraySizeMax = size_t(0);
}

/**
  Clone function
  @returns a clone of the validator
  */
template <typename TYPE>
IValidator_sptr ArrayLengthValidator<TYPE>::clone() const {
  return boost::make_shared<ArrayLengthValidator>(*this);
}

/**
Private function to check validity
@returns a string. The string is emty if everything is OK, otherwise returns the
error
*/
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
} // namespace Kernel