ListValidator.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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/Exception.h"
#include "MantidKernel/TypedValidator.h"
#ifndef Q_MOC_RUN
#include <boost/lexical_cast.hpp>
#include <memory>
#endif
#include <algorithm>
#include <map>
#include <set>
#include <unordered_set>
#include <vector>
 
namespace Mantid {
namespace Kernel {
template <typename TYPE> class ListValidator : public TypedValidator<TYPE> {
public:
  ListValidator() : TypedValidator<TYPE>(), m_allowMultiSelection(false) {}
 
  template <typename T>
  explicit ListValidator(const T &values,
                         const std::map<std::string, std::string> &aliases = std::map<std::string, std::string>(),
                         const bool allowMultiSelection = false)
      : TypedValidator<TYPE>(), m_allowedValues(values.begin(), values.end()),
        m_aliases(aliases.begin(), aliases.end()), m_allowMultiSelection(allowMultiSelection) {
    if (m_allowMultiSelection) {
      throw Kernel::Exception::NotImplementedError("The List Validator does not support multi selection yet");
    }
    for (auto aliasIt = m_aliases.begin(); aliasIt != m_aliases.end(); ++aliasIt) {
      if (values.end() == std::find(values.begin(), values.end(), boost::lexical_cast<TYPE>(aliasIt->second))) {
        throw std::invalid_argument("Alias " + aliasIt->first + " refers to invalid value " + aliasIt->second);
      }
    }
  }
 
  IValidator_sptr clone() const override { return std::make_shared<ListValidator<TYPE>>(*this); }
  std::vector<std::string> allowedValues() const override {
    std::vector<std::string> allowedStrings;
    allowedStrings.reserve(m_allowedValues.size());
    auto cend = m_allowedValues.end();
    for (auto cit = m_allowedValues.begin(); cit != cend; ++cit) {
      allowedStrings.emplace_back(boost::lexical_cast<std::string>(*cit));
    }
    return allowedStrings;
  }
 
  void addAllowedValue(const TYPE &value) {
    // add only new values
    if (std::find(m_allowedValues.begin(), m_allowedValues.end(), value) == m_allowedValues.end()) {
      m_allowedValues.emplace_back(value);
    }
  }
 
  std::string getValueForAlias(const std::string &alias) const override {
    auto aliasIt = m_aliases.find(alias);
    if (aliasIt == m_aliases.end()) {
      throw std::invalid_argument("Unknown alias found " + alias);
    }
    return aliasIt->second;
  }
 
  bool isMultipleSelectionAllowed() override { return m_allowMultiSelection; }
 
  void setMultipleSelectionAllowed(const bool isMultiSelectionAllowed) {
    if (isMultiSelectionAllowed) {
      throw Kernel::Exception::NotImplementedError("The List Validator does not support Multi selection yet");
    }
    m_allowMultiSelection = isMultiSelectionAllowed;
  }
 
protected:
  std::string checkValidity(const TYPE &value) const override {
    if (m_allowedValues.end() != std::find(m_allowedValues.begin(), m_allowedValues.end(), value)) {
      return "";
    } else {
      // For a generic type, isEmpty always returns false, but if TYPE is std::string,
      // then the string version of isEmpty will be used, which could be true or false.
      if (isEmpty(value))
        return "Select a value";
      if (isAlias(value))
        return "_alias";
      std::ostringstream os;
      os << "The value \"" << value << "\" is not in the list of allowed values";
      return os.str();
    }
  }
 
  template <typename T> bool isEmpty(const T &value) const { UNUSED_ARG(value) return false; }
  bool isEmpty(const std::string &value) const { return value.empty(); }
 
  template <typename T> bool isAlias(const T &value) const {
    std::string strValue = boost::lexical_cast<std::string>(value);
    return m_aliases.find(strValue) != m_aliases.end();
  }
 
  bool isAlias(const std::string &value) const { return m_aliases.find(value) != m_aliases.end(); }
 
  std::vector<TYPE> m_allowedValues;
  std::map<std::string, std::string> m_aliases;
 
  bool m_allowMultiSelection;
};
 
using StringListValidator = ListValidator<std::string>;
 
} // namespace Kernel
} // namespace Mantid