ParameterRegistry.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 <map>

#include "libmesh/parameters.h"

#include "MooseError.h"

#ifdef MOOSE_UNIT_TEST
#include "gtest/gtest.h"
class GTEST_TEST_CLASS_NAME_(ParameterRegistryTest, add);
class GTEST_TEST_CLASS_NAME_(ParameterRegistryTest, addExists);
class GTEST_TEST_CLASS_NAME_(ParameterRegistryTest, set);
class GTEST_TEST_CLASS_NAME_(ParameterRegistryTest, setNotRegistered);
class GTEST_TEST_CLASS_NAME_(ParameterRegistryTest, setCatchMooseError);
#endif

namespace hit
{
class Field;
}

namespace Moose
{

class ParameterRegistry
{
public:
  static ParameterRegistry & get();

  template <class T, class F>
  char add(F && f);

  void set(libMesh::Parameters::Value & value, const hit::Field & field) const;

private:
  ParameterRegistry() {};

#ifdef MOOSE_UNIT_TEST
  FRIEND_TEST(::ParameterRegistryTest, add);
  FRIEND_TEST(::ParameterRegistryTest, addExists);
  FRIEND_TEST(::ParameterRegistryTest, set);
  FRIEND_TEST(::ParameterRegistryTest, setNotRegistered);
  FRIEND_TEST(::ParameterRegistryTest, setCatchMooseError);
#endif

  std::map<std::string, std::function<void(libMesh::Parameters::Value & value, const hit::Field &)>>
      _registry;
};

template <class T, class F>
char
ParameterRegistry::add(F && f)
{
  static_assert(std::is_invocable_r_v<void, F &, T &, const hit::Field &>,
                "Setter function must be callable with (T &, const hit::Field &) and return void");

  // We register a function that stores T &, but the registry will only ever be
  // called from a bare libMesh::Parameters::Value. Thus, we need to cast the
  // bare Value to the derived value and then call the setter.
  auto setter = [f = std::forward<F>(f)](libMesh::Parameters::Value & param_value,
                                         const hit::Field & field) -> void
  {
    auto cast_param_value = dynamic_cast<libMesh::Parameters::Parameter<T> *>(&param_value);
    mooseAssert(cast_param_value, "Cast failed");
    f(cast_param_value->set(), field);
  };

  const auto key = demangle(typeid(T).name());
  const auto it_inserted_pair = _registry.emplace(key, std::move(setter));

  if (!it_inserted_pair.second)
    mooseError("ParameterRegistry: Parameter with type '", key, "' is already registered");

  return 0;
}

} // end of namespace Moose