ArrayBoundedValidator.cpp

#include "MantidKernel/ArrayBoundedValidator.h"

#include <iostream>
#include <sstream>
#include <string>

namespace Mantid
{
namespace Kernel
{

/**
 * Default constructor
 */
template <typename TYPE>
ArrayBoundedValidator<TYPE>::ArrayBoundedValidator() : 
  TypedValidator<std::vector<TYPE> >(),
  boundVal(boost::make_shared<BoundedValidator<TYPE> >())
{
}

/**
 * Copy constructor
 * @param abv :: the ArrayBoundedValidator to copy
 */
template <typename TYPE>
ArrayBoundedValidator<TYPE>::ArrayBoundedValidator(const ArrayBoundedValidator<TYPE> &abv) 
  : TypedValidator<std::vector<TYPE> >()
{
  this->boundVal = boost::dynamic_pointer_cast<BoundedValidator<TYPE> >(abv.boundVal->clone());
}

/**
 * Constructor via bounds parameters
 * @param lowerBound :: the lower bound value to validate
 * @param upperBound :: the upper bound value to validate
 */
template <typename TYPE>
ArrayBoundedValidator<TYPE>::ArrayBoundedValidator(const TYPE lowerBound, const TYPE upperBound) 
  : TypedValidator<std::vector<TYPE> >(),
    boundVal(boost::make_shared<BoundedValidator<TYPE> >(lowerBound, upperBound))
{
}

/**
 * Constructor via a BoundedValidator
 * @param bv :: the BoundedValidator object to use
 */
template <typename TYPE>
ArrayBoundedValidator<TYPE>::ArrayBoundedValidator(BoundedValidator<TYPE> &bv)
{
  this->boundVal = boost::dynamic_pointer_cast<BoundedValidator<TYPE> >(bv.clone());
}

/**
 * Object destructor
 */
template <typename TYPE>
ArrayBoundedValidator<TYPE>::~ArrayBoundedValidator()
{
}

/**
 * Create a clone of the current ArrayBoundedValidator
 * @return the cloned object
 */
template <typename TYPE>
IValidator_sptr ArrayBoundedValidator<TYPE>::clone() const
{
  return boost::make_shared<ArrayBoundedValidator<TYPE> >(*this);
}

/**
 * Accessor for the stored BoundedValidator
 * @return a pointer to the stored BoundedValidator
 */
template <typename TYPE>
boost::shared_ptr<BoundedValidator<TYPE> > ArrayBoundedValidator<TYPE>::getValidator() const
{
  return this->boundVal;
}

/**
 * Function that actually does the work of checking the validity of the
 * array elements.
 * @param value :: the array to be checked
 * @return a listing of the indicies that fail the bounds checks
 */
template <typename TYPE>
std::string
ArrayBoundedValidator<TYPE>::checkValidity( const std::vector<TYPE> &value ) const
{
  // declare a class that can do conversions to string
  std::ostringstream error;
  // load in the "no error" condition
  error << "";
  typename std::vector<TYPE>::const_iterator it;
  std::size_t index = 0;
  for (it = value.begin(); it != value.end(); ++it)
  {
    std::string retval = this->boundVal->isValid(*it);
    if ( !retval.empty() )
    {
      error << "At index " << index << ": " << retval;
    }
    index++;
  }

  return error.str();
}

template <typename TYPE>
bool ArrayBoundedValidator<TYPE>::hasLower() const
{
  return this->boundVal->hasLower();
}

template <typename TYPE>
bool ArrayBoundedValidator<TYPE>::hasUpper() const
{
  return this->boundVal->hasUpper();
}

template <typename TYPE>
const TYPE& ArrayBoundedValidator<TYPE>::lower() const
{
  return this->boundVal->lower();
}

template <typename TYPE>
const TYPE& ArrayBoundedValidator<TYPE>::upper() const
{
  return this->boundVal->upper();
}

template <typename TYPE>
void ArrayBoundedValidator<TYPE>::setLower( const TYPE& value )
{
  this->boundVal->setLower(value);
}

template <typename TYPE>
void ArrayBoundedValidator<TYPE>::setUpper( const TYPE& value )
{
  this->boundVal->setUpper(value);
}

template <typename TYPE>
void ArrayBoundedValidator<TYPE>::clearLower()
{
  this->boundVal->clearLower();
}

template <typename TYPE>
void ArrayBoundedValidator<TYPE>::clearUpper()
{
  this->boundVal->clearUpper();
}

// Required explicit instantiations
template class ArrayBoundedValidator<double>;
template class ArrayBoundedValidator<int>;
template class ArrayBoundedValidator<long>;

} // Kernel
} // Mantid