field_modifier_registry.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef PFC_UI_FIELD_MODIFIER_REGISTRY_HPP
#define PFC_UI_FIELD_MODIFIER_REGISTRY_HPP
 
#include "errors.hpp"
#include "from_json.hpp"
#include "openpfc/boundary_conditions/fixed_bc.hpp"
#include "openpfc/boundary_conditions/moving_bc.hpp"
#include "openpfc/field_modifier.hpp"
#include "openpfc/initial_conditions/constant.hpp"
#include "openpfc/initial_conditions/file_reader.hpp"
#include "openpfc/initial_conditions/random_seeds.hpp"
#include "openpfc/initial_conditions/seed_grid.hpp"
#include "openpfc/initial_conditions/single_seed.hpp"
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
 
namespace pfc {
namespace ui {
 
using FieldModifier_p = std::unique_ptr<FieldModifier>;
 
class FieldModifierRegistry {
public:
  using CreatorFunction = std::function<FieldModifier_p(const json &)>;
 
  static FieldModifierRegistry &get_instance() {
    static FieldModifierRegistry instance;
    return instance;
  }
 
  void register_modifier(const std::string &type, CreatorFunction creator) {
    modifiers[type] = creator;
  }
 
  FieldModifier_p create_modifier(const std::string &type, const json &data) {
    auto it = modifiers.find(type);
    if (it != modifiers.end()) {
      return it->second(data);
    }
    throw std::invalid_argument(format_unknown_modifier_error(type));
  }
 
private:
  FieldModifierRegistry() {}
 
  std::unordered_map<std::string, CreatorFunction>
      modifiers; 
};
 
template <typename T> void register_field_modifier(const std::string &type) {
  FieldModifierRegistry::get_instance().register_modifier(
      type, [](const json &params) -> std::unique_ptr<T> {
        std::unique_ptr<T> modifier = std::make_unique<T>();
        from_json(params, *modifier);
        return modifier;
      });
}
 
std::unique_ptr<FieldModifier> create_field_modifier(const std::string &type,
                                                     const json &params) {
  return FieldModifierRegistry::get_instance().create_modifier(type, params);
}
 
struct FieldModifierInitializer {
  FieldModifierInitializer() {
    // Initial conditions
    register_field_modifier<Constant>("constant");
    register_field_modifier<SingleSeed>("single_seed");
    register_field_modifier<RandomSeeds>("random_seeds");
    register_field_modifier<SeedGrid>("seed_grid");
    register_field_modifier<FileReader>("from_file");
    // Boundary conditions
    register_field_modifier<FixedBC>("fixed");
    register_field_modifier<MovingBC>("moving");
    // Register other field modifiers here ...
  }
};
 
static FieldModifierInitializer
    fieldModifierInitializer; 
} // namespace ui
} // namespace pfc
 
#endif // PFC_UI_FIELD_MODIFIER_REGISTRY_HPP