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/IValidator.h"
#include <typeinfo>
 
namespace Mantid {
namespace Kernel {
template <typename HeldType> class DLLExport TypedValidator : public IValidator {
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.";
    }
  }
};
 
template <typename ElementType> class DLLExport TypedValidator<std::shared_ptr<ElementType>> : public IValidator {
  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() == m_dataitemTypeID.hash_code())
#else
    if (value.type() == m_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 &m_dataitemTypeID;
};
 
// This switch off an warning because oxygen could not figureout that this is a
// specialized type of the general one.
template <typename T>
const std::type_info &TypedValidator<std::shared_ptr<T>>::m_dataitemTypeID = typeid(std::shared_ptr<DataItem>);
} // namespace Kernel
} // namespace Mantid