PropertyWithValueJSON.cpp

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 +
#include "MantidKernel/PropertyWithValueJSON.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidKernel/OptionalBool.h"
#include "MantidKernel/PropertyManager.h"
#include "MantidKernel/PropertyManagerProperty.h"
#include <json/value.h>
#include <map>
 
using Json::Value;
 
namespace Mantid::Kernel {
 
namespace {
 
// A pointer to a member function for doing the Json::Value->C++ type conversion
// Used only for type deduction in the FromJson constructor
template <typename T> using ValueAsTypeMemFn = T (Json::Value::*)() const;
 
// A non-templated outer struct that can be stored in a container without
// requiring a pointer. The implementation follows the concept-model idiom
// of storing the templated type using type erasure. Creating an object
// of this type uses the type passed to the constructor to infer the
// template parameter type. This template type is then used to call
// the appropriate ToCpp conversion function defined in the header when
// createProperty is called.
struct FromJson {
  template <typename T> explicit FromJson(ValueAsTypeMemFn<T> /*unused*/) : m_self{std::make_unique<ModelT<T>>()} {}
 
  std::unique_ptr<Property> createProperty(const std::string &name, const Json::Value &value, bool createArray) const {
    if (createArray)
      return m_self->arrayValueProperty(name, value);
    else
      return m_self->singleValueProperty(name, value);
  }
 
private:
  struct ConceptT {
    virtual ~ConceptT() = default;
    virtual std::unique_ptr<Property> singleValueProperty(const std::string &name, const Json::Value &value) const = 0;
    virtual std::unique_ptr<Property> arrayValueProperty(const std::string &name, const Json::Value &value) const = 0;
  };
 
  template <typename T> struct ModelT : ConceptT {
    std::unique_ptr<Property> singleValueProperty(const std::string &name,
                                                  const Json::Value &value) const override final {
      using ToCppT = pwvjdetail::ToCpp<T>;
      return std::make_unique<PropertyWithValue<T>>(name, ToCppT()(value));
    }
 
    std::unique_ptr<Property> arrayValueProperty(const std::string &name,
                                                 const Json::Value &value) const override final {
      using ToCppVectorT = pwvjdetail::ToCpp<std::vector<T>>;
      return std::make_unique<ArrayProperty<T>>(name, ToCppVectorT()(value));
    }
  };
  std::unique_ptr<ConceptT> m_self;
};
 
// Define a lookup mapping Json::ValueTypes to a FromJson able to
// create a PropertyWithValue object from that type
using FromJsonConverters = std::map<Json::ValueType, FromJson>;
 
// Returns (and creates on first call) the map of Json::ValueType to
// FromJson for converting a JsonValue to a Property object
const FromJsonConverters &converters() {
  static FromJsonConverters converters;
  if (converters.empty()) {
    // Build a map of Json types to FromJson converters of the appropriate type
    converters.insert(std::make_pair(Json::booleanValue, FromJson(&Json::Value::asBool)));
    converters.insert(std::make_pair(Json::intValue, FromJson(&Json::Value::asInt)));
    converters.insert(std::make_pair(Json::realValue, FromJson(&Json::Value::asDouble)));
    converters.insert(std::make_pair(Json::stringValue, FromJson(&Json::Value::asString)));
  }
  return converters;
}
 
std::unique_ptr<Property> createSingleTypeProperty(const std::string &name, const Json::Value &value) {
  const auto isArray = value.isArray();
  FromJsonConverters::const_iterator conversionFnIter;
  // For an array use the first element as the type checker and the rest must
  // be convertible
  if (isArray)
    conversionFnIter = converters().find(value[0].type());
  else
    conversionFnIter = converters().find(value.type());
 
  if (conversionFnIter == converters().end()) {
    throw std::invalid_argument("Cannot create property with name " + name +
                                ". Unable to find converter "
                                "for Json::ValueType to C++ "
                                "type");
  }
  return conversionFnIter->second.createProperty(name, value, value.isArray());
}
 
std::unique_ptr<Property> createKeyValueProperty(const std::string &name, const Json::Value &keyValues) {
  return std::make_unique<PropertyManagerProperty>(name, createPropertyManager(keyValues));
}
 
} // namespace
 
PropertyManager_sptr createPropertyManager(const Json::Value &keyValues) {
  auto propMgr = std::make_shared<PropertyManager>();
  auto members = keyValues.getMemberNames();
  for (const auto &key : members) {
    const auto &value = keyValues[key];
    if (value.isObject())
      propMgr->declareProperty(createKeyValueProperty(key, value));
    else
      propMgr->declareProperty(createSingleTypeProperty(key, value));
  }
  return propMgr;
}
 
std::unique_ptr<Property> decodeAsProperty(const std::string &name, const Json::Value &value) {
  if (value.isNull()) {
    throw std::invalid_argument("decodeAsProperty(): Found null Json value.");
  }
 
  if (!value.isObject()) {
    return createSingleTypeProperty(name, value);
  } else {
    return createKeyValueProperty(name, value);
  }
}
 
} // namespace Mantid::Kernel