TypeRegistry.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include "MantidPythonInterface/kernel/Registry/TypeRegistry.h"
#include "MantidPythonInterface/kernel/Registry/SequenceTypeHandler.h"
#include "MantidPythonInterface/kernel/Registry/TypedPropertyValueHandler.h"
#include <boost/python/type_id.hpp>
#include <map>
 
namespace Mantid::PythonInterface::Registry {
namespace // <anonymous>
{
using TypeIDMap = std::map<const boost::python::type_info, std::shared_ptr<PropertyValueHandler>>;
 
TypeIDMap &typeRegistry() {
  static TypeIDMap typeHandlers;
  return typeHandlers;
}
} // namespace
 
//-------------------------------------------------------------------------------------------
// Public methods
//-------------------------------------------------------------------------------------------
 
void TypeRegistry::registerBuiltins() {
// -- Register a handler for each basic type and vector of each basic type +
// std::string --
// macro helps with keeping information in one place
#define SUBSCRIBE_HANDLER(Type)                                                                                        \
  subscribe<TypedPropertyValueHandler<Type>>();                                                                        \
  subscribe<SequenceTypeHandler<std::vector<Type>>>();
 
  // unsigned ints
  SUBSCRIBE_HANDLER(int);
  SUBSCRIBE_HANDLER(long);
  SUBSCRIBE_HANDLER(long long);
  // signed ints
  SUBSCRIBE_HANDLER(unsigned int);
  SUBSCRIBE_HANDLER(unsigned long);
  SUBSCRIBE_HANDLER(unsigned long long);
  // boolean
  SUBSCRIBE_HANDLER(bool);
  // double
  SUBSCRIBE_HANDLER(double);
  // string
  SUBSCRIBE_HANDLER(std::string);
 
#undef SUBSCRIBE_HANDLER
}
 
void TypeRegistry::subscribe(const std::type_info &typeObject, PropertyValueHandler *handler) {
  TypeIDMap &typeHandlers = typeRegistry();
  boost::python::type_info typeInfo(typeObject);
  if (typeHandlers.find(typeInfo) == typeHandlers.end()) {
    typeHandlers.emplace(typeInfo, std::shared_ptr<PropertyValueHandler>(handler));
  } else {
    throw std::invalid_argument(std::string("TypeRegistry::subscribe() - A handler has already "
                                            "registered for type '") +
                                typeInfo.name() + "'");
  }
}
 
const PropertyValueHandler &TypeRegistry::retrieve(const std::type_info &typeObject) {
  TypeIDMap &typeHandlers = typeRegistry();
  TypeIDMap::const_iterator itr = typeHandlers.find(boost::python::type_info(typeObject));
  if (itr != typeHandlers.end()) {
    return *(itr->second);
  } else {
    throw std::invalid_argument(std::string("TypeRegistry::retrieve(): No PropertyValueHandler "
                                            "registered for type '") +
                                boost::python::type_info(typeObject).name() + "'");
  }
}
} // namespace Mantid::PythonInterface::Registry