IValidator.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/DataItem.h"
#include "MantidKernel/DllConfig.h"
 
#ifndef Q_MOC_RUN
#include <boost/any.hpp>
#include <memory>
#endif
#include <stdexcept>
#include <vector>
 
namespace Mantid {
namespace Kernel {
// Forward declaration so that the typedef std::shared_ptr<Validator>
// understand it
class IValidator;
 
using IValidator_sptr = std::shared_ptr<IValidator>;
 
namespace {
template <class T> struct IsPtrType : public std::is_pointer<T> {};
template <class T> struct IsPtrType<std::shared_ptr<T>> : public std::true_type {};
template <> struct IsPtrType<decltype(nullptr)> : public std::true_type {};
} // namespace
 
class MANTID_KERNEL_DLL IValidator {
public:
  IValidator() = default;
 
  virtual ~IValidator() = default;
 
  //------------------------------------------------------------------------------------------------------------
  template <typename TYPE> std::string isValid(const TYPE &value) const { return runCheck(value, IsPtrType<TYPE>()); }
 
  std::string isValid(const char *value) const { return isValid(std::string(value)); }
 
  //------------------------------------------------------------------------------------------------------------
  virtual std::vector<std::string> allowedValues() const { return std::vector<std::string>(); }
 
  virtual bool isMultipleSelectionAllowed() { return false; };
 
  virtual std::string getValueForAlias(const std::string &alias) const {
    UNUSED_ARG(alias);
    throw std::invalid_argument("Validator does'n support value aliasing.");
  }
 
  virtual IValidator_sptr clone() const = 0;
 
  virtual std::string check(const boost::any &) const = 0;
 
private:
  template <typename T> std::string runCheck(const T &value, const std::false_type &) const {
    const T *valuePtr = &value; // Avoid a copy by storing the pointer in the any holder
    return check(boost::any(valuePtr));
  }
 
  template <typename T> std::string runCheck(const T &value, const std::true_type &) const {
    return runCheckWithDataItemPtr(value, std::integral_constant < bool,
                                   std::is_convertible<T, DataItem_sptr>::value &&
                                       !std::is_same<T, decltype(nullptr)>::value > ());
  }
  template <typename T> std::string runCheckWithDataItemPtr(const T &value, const std::false_type &) const {
    return check(boost::any(value));
  }
  template <typename T> std::string runCheckWithDataItemPtr(const T &value, const std::true_type &) const {
    return check(boost::any(std::static_pointer_cast<DataItem>(value)));
  }
};
 
} // namespace Kernel
} // namespace Mantid