TypedValidator.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2012 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
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/IValidator.h"
#include <string>
#include <typeinfo>
#include <vector>
 
namespace Mantid {
namespace Kernel {
#if !defined(_WIN32)
template <typename HeldType> class MANTID_KERNEL_DLL TypedValidator : public IValidator {
#else
template <typename HeldType> class TypedValidator : public IValidator {
#endif
public:
  TypedValidator() = default;
  TypedValidator(const TypedValidator &) = default;
  TypedValidator(TypedValidator &&);
  TypedValidator &operator=(const TypedValidator &) = default;
  TypedValidator &operator=(TypedValidator &&);
  ~TypedValidator() override = default;
 
protected:
  virtual std::string checkValidity(const HeldType &) const = 0;
 
private:
  std::string check(const boost::any &value) const override {
    try {
      const HeldType *dataPtr = boost::any_cast<const HeldType *>(value);
      return checkValidity(*dataPtr);
    } catch (boost::bad_any_cast &) {
      return "Value was not of expected type.";
    }
  }
};
 
// The move operations are defaulted out of line so that they are user-provided:
// an exported explicit instantiation then exports them, whereas MSVC does not
// export implicitly-declared move members.
template <typename HeldType> TypedValidator<HeldType>::TypedValidator(TypedValidator &&) = default;
template <typename HeldType> TypedValidator<HeldType> &TypedValidator<HeldType>::operator=(TypedValidator &&) = default;
 
#if !defined(_WIN32)
template <typename ElementType>
class MANTID_KERNEL_DLL TypedValidator<std::shared_ptr<ElementType>> : public IValidator {
#else
template <typename ElementType> class TypedValidator<std::shared_ptr<ElementType>> : public IValidator {
#endif
  using ElementType_sptr = std::shared_ptr<ElementType>;
 
protected:
  virtual std::string checkValidity(const ElementType_sptr &) const = 0;
 
private:
  std::string check(const boost::any &value) const override {
    try {
      const ElementType_sptr typedValue = extractValue(value);
      return checkValidity(typedValue);
    } catch (std::invalid_argument &exc) {
      return exc.what();
    }
  }
  ElementType_sptr extractValue(const boost::any &value) const {
// Despite the name and hash code being identical, operator== is returning false
// in Release mode
// with clang and libc++. The simplest workaround is to compare hash codes.
#ifdef __clang__
    if (value.type().hash_code() == dataitemTypeID().hash_code())
#else
    if (value.type() == dataitemTypeID())
#endif
    {
      return extractFromDataItem(value);
    } else {
      return extractFromSharedPtr(value);
    }
  }
  ElementType_sptr extractFromDataItem(const boost::any &value) const {
    const DataItem_sptr data = boost::any_cast<DataItem_sptr>(value);
    // First try and push it up to the type of the validator
    ElementType_sptr typedValue = std::dynamic_pointer_cast<ElementType>(data);
    if (!typedValue) {
      throw std::invalid_argument("DataItem \"" + data->getName() + "\" is not of the expected type.");
    }
    return typedValue;
  }
  ElementType_sptr extractFromSharedPtr(const boost::any &value) const {
    try {
      return boost::any_cast<ElementType_sptr>(value);
    } catch (boost::bad_any_cast &) {
      throw std::invalid_argument("Value was not a shared_ptr type");
    }
  }
  static const std::type_info &dataitemTypeID() { return typeid(std::shared_ptr<DataItem>); }
};
 
// Instantiated and exported by StartsWithValidator.cpp and ArrayLengthValidator.cpp. They are the bases of exported
// validator classes, so consumers must not instantiate their own copy of the inline base members.
MANTID_KERNEL_EXTERN_TEMPLATE(TypedValidator<std::string>);
MANTID_KERNEL_EXTERN_TEMPLATE(TypedValidator<std::vector<double>>);
 
// This switch off an warning because oxygen could not figureout that this is a
// specialized type of the general one.
} // namespace Kernel
} // namespace Mantid