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 <string>
#include <map>
#include <type_traits>

#include "MooseError.h"

#include "minijson/minijson.h"

class WebServerControl;

namespace Moose
{
class WebServerControlTypeRegistry
{
public:
  static WebServerControlTypeRegistry & getRegistry();

  class ValueBase
  {
  public:
    ValueBase(const std::string & name, const std::string & type) : _name(name), _type(type) {}
    virtual ~ValueBase() {}

    const std::string & name() const { return _name; }
    const std::string & type() const { return _type; }

    virtual void setControllableValue(WebServerControl & control) = 0;

    struct Exception : public std::exception
    {
    public:
      Exception(const std::string & message) : _message(message) {}
      virtual const char * what() const noexcept override final { return _message.c_str(); }

    private:
      const std::string _message;
    };

  private:
    const std::string _name;
    const std::string _type;
  };

  template <typename DerivedValueType>
  static char add(const std::string & type_name)
  {
    static_assert(std::is_base_of_v<ValueBase, DerivedValueType>, "Is not derived from ValueBase");
    getRegistry()._types.emplace(type_name, std::make_unique<Type<DerivedValueType>>(type_name));
    return 0;
  }

  static bool isRegistered(const std::string & type) { return getRegistry()._types.count(type); }

  static std::unique_ptr<ValueBase> build(const std::string & type, const std::string & name)
  {
    return get(type).build(name);
  }
  static std::unique_ptr<ValueBase>
  build(const std::string & type, const std::string & name, const miniJson::Json & json_value)
  {
    return get(type).build(name, json_value);
  }

private:
  class TypeBase
  {
  public:
    TypeBase(const std::string & type) : _type(type) {}
    virtual ~TypeBase() {}

    const std::string & type() const { return _type; }
    virtual std::unique_ptr<ValueBase> build(const std::string & name,
                                             const miniJson::Json & json_value) const = 0;
    virtual std::unique_ptr<ValueBase> build(const std::string & name) const = 0;

  private:
    const std::string _type;
  };

  template <class DerivedValueType>
  struct Type : public TypeBase
  {
    Type(const std::string & type) : TypeBase(type) {}

    virtual std::unique_ptr<ValueBase> build(const std::string & name) const override final
    {
      return std::make_unique<DerivedValueType>(name, type());
    }
    virtual std::unique_ptr<ValueBase> build(const std::string & name,
                                             const miniJson::Json & json_value) const override final
    {
      return std::make_unique<DerivedValueType>(name, type(), json_value);
    }
  };

  static const TypeBase & get(const std::string & type)
  {
    auto & registry = getRegistry();
    const auto it = registry._types.find(type);
    if (it == registry._types.end())
      mooseError("WebServerControlTypeRegistry: The type '", type, "' is not registered");
    return *it->second;
  }

  std::map<std::string, std::unique_ptr<TypeBase>> _types;
};
}