library.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2026 by the ryujin authors
//
 
#pragma once
 
#include <ryujin/base/compile_time_options.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/patterns.h>
 
#include <algorithm>
#include <concepts>
#include <functional>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
namespace ryujin
{
  template <typename Base, typename... Args>
  class Library final
  {
  public:
    Library() = delete;
 
    using Creator = std::function<std::unique_ptr<Base>(Args...)>;
 
    template <typename T>
      requires std::derived_from<T, Base> && std::constructible_from<T, Args...>
    static Creator creator()
    {
      return [](Args... args) -> std::unique_ptr<Base> {
        return std::make_unique<T>(args...);
      };
    }
 
    static void add(Creator creator);
 
    template <typename T>
      requires std::derived_from<T, Base> && std::constructible_from<T, Args...>
    static void add()
    {
      add(creator<T>());
    }
 
    static std::vector<std::unique_ptr<Base>> create(Args... args);
 
    static std::vector<std::string> names(Args... args);
 
    static dealii::Patterns::Selection
    selection(const std::vector<std::unique_ptr<Base>> &objects);
 
    static Base &select(const std::vector<std::unique_ptr<Base>> &objects,
                        const std::string &name);
 
  private:
    static std::vector<Creator> &creators();
 
    static std::vector<Creator> defaults();
  };
 
 
  // ----------------------------- member functions ---------------------------
 
 
  template <typename Base, typename... Args>
  auto Library<Base, Args...>::creators() -> std::vector<Creator> &
  {
    static std::vector<Creator> creators = defaults();
    return creators;
  }
 
 
  template <typename Base, typename... Args>
  void Library<Base, Args...>::add(Creator creator)
  {
    creators().push_back(std::move(creator));
  }
 
 
  template <typename Base, typename... Args>
  std::vector<std::unique_ptr<Base>>
  Library<Base, Args...>::create(Args... args)
  {
    std::vector<std::unique_ptr<Base>> objects;
    std::set<std::string> names;
 
    for (const auto &creator : creators()) {
      auto object = creator(args...);
      const auto [it, inserted] = names.insert(object->name());
      AssertThrow(
          inserted,
          dealii::ExcMessage("Two entries of a library share the name »" +
                             object->name() + "«"));
      objects.push_back(std::move(object));
    }
 
    return objects;
  }
 
 
  template <typename Base, typename... Args>
  std::vector<std::string> Library<Base, Args...>::names(Args... args)
  {
    std::vector<std::string> names;
    for (const auto &object : create(args...))
      names.push_back(object->name());
    return names;
  }
 
 
  template <typename Base, typename... Args>
  dealii::Patterns::Selection Library<Base, Args...>::selection(
      const std::vector<std::unique_ptr<Base>> &objects)
  {
    std::string names;
    for (const auto &object : objects)
      names += (names.empty() ? "" : "|") + object->name();
    return dealii::Patterns::Selection(names);
  }
 
 
  template <typename Base, typename... Args>
  Base &Library<Base, Args...>::select(
      const std::vector<std::unique_ptr<Base>> &objects,
      const std::string &name)
  {
    const auto it =
        std::find_if(objects.begin(), objects.end(), [&](const auto &object) {
          return object->name() == name;
        });
 
    AssertThrow(it != objects.end(),
                dealii::ExcMessage("No entry of the library has the name »" +
                                   name + "«"));
 
    return **it;
  }
} // namespace ryujin