WebServerControlTypeRegistry.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include <functional>
#include <string>
#include <map>
#include <type_traits>
#include <typeindex>
 
#include "nlohmann/json.h"
 
#include "MooseError.h"
#include "MooseUtils.h"
 
class WebServerControl;
 
namespace Moose
{
class WebServerControlTypeRegistry
{
public:
  static WebServerControlTypeRegistry & getRegistry();
 
  class ControlledValueBase
  {
  public:
    ControlledValueBase(const std::string & name, const std::string & type);
 
    virtual ~ControlledValueBase() {}
 
    const std::string & name() const { return _name; }
    const std::string & type() const { return _type; }
 
    virtual void setControllableValue(WebServerControl & control) = 0;
 
  private:
    const std::string _name;
    const std::string _type;
  };
 
  class RegisteredTypeBase
  {
  public:
    RegisteredTypeBase(const std::string & type);
 
    virtual ~RegisteredTypeBase() {}
 
    const std::string & type() const { return _type; }
    virtual std::unique_ptr<ControlledValueBase> build(const std::string & name,
                                                       const nlohmann::json & json_value) const = 0;
    virtual std::unique_ptr<ControlledValueBase> build(const std::string & name) const = 0;
 
  private:
    const std::string _type;
  };
 
  template <class ControlledValue, class ValueType>
  struct RegisteredType : public RegisteredTypeBase
  {
    RegisteredType(const std::string & type,
                   std::function<ValueType(const nlohmann::json &)> && parse_function)
      : RegisteredTypeBase(type), _parse_function(parse_function)
    {
    }
 
    virtual std::unique_ptr<ControlledValueBase>
    build(const std::string & name) const override final
    {
      return std::make_unique<ControlledValue>(name, type());
    }
    virtual std::unique_ptr<ControlledValueBase>
    build(const std::string & name, const nlohmann::json & json_value) const override final
    {
      return std::make_unique<ControlledValue>(name, type(), _parse_function(json_value));
    }
 
  private:
    const std::function<ValueType(const nlohmann::json &)> _parse_function;
  };
 
  template <class ControlledValue, class ValueType>
  static char add(const std::string & type_name,
                  std::function<ValueType(const nlohmann::json &)> && parse_function);
 
  static const RegisteredTypeBase * query(const std::string & type);
 
  static const RegisteredTypeBase & get(const std::string & type);
 
private:
  std::map<std::string, std::unique_ptr<RegisteredTypeBase>> _name_map;
  std::set<std::type_index> _value_types;
};
 
template <class ControlledValue, class ValueType>
char
WebServerControlTypeRegistry::add(
    const std::string & type_name,
    std::function<ValueType(const nlohmann::json &)> && parse_function)
{
  static_assert(std::is_base_of_v<ControlledValueBase, ControlledValue>,
                "Is not derived from ControlledValueBase");
  static_assert(std::is_same_v<typename ControlledValue::value_type, ValueType>, "Is not the same");
 
  auto entry = std::make_unique<RegisteredType<ControlledValue, ValueType>>(
      type_name, std::move(parse_function));
  if (!getRegistry()._name_map.emplace(type_name, std::move(entry)).second)
    ::mooseError(
        "WebServerControlTypeRegistry: The string type \"", type_name, "\" is already registered.");
 
  static const std::type_index index = typeid(ValueType);
  if (!getRegistry()._value_types.insert(index).second)
    ::mooseError("WebServerControlRegistry: The type \"",
                 MooseUtils::prettyCppType<ValueType>(),
                 "\" is already registered");
  return 0;
}
}