AppFactory.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 <vector>

#include "MooseApp.h"

// Forward declarations
class InputParameters;

#define registerApp(name) AppFactory::instance().reg<name>(#name)

using MooseAppPtr = std::shared_ptr<MooseApp>;

struct AppFactoryBuildInfoBase
{
  virtual MooseAppPtr build(const InputParameters & params) = 0;
  virtual InputParameters buildParameters() = 0;
  virtual ~AppFactoryBuildInfoBase() = default;

  std::size_t _app_creation_count = 0;
};
template <typename T>
struct AppFactoryBuildInfo : public AppFactoryBuildInfoBase
{
  virtual MooseAppPtr build(const InputParameters & params) override
  {
    return std::make_shared<T>(params);
  }
  virtual InputParameters buildParameters() override { return T::validParams(); }
};

using AppFactoryBuildInfoMap = std::map<std::string, std::unique_ptr<AppFactoryBuildInfoBase>>;

class AppFactory
{
public:
  static AppFactory & instance();

  virtual ~AppFactory();

  static InputParameters validParams();
  static MooseAppPtr createAppShared(const std::string & default_app_type,
                                     int argc,
                                     char ** argv,
                                     std::unique_ptr<Parser> parser,
                                     MPI_Comm comm_word = MPI_COMM_WORLD);

  static MooseAppPtr createAppShared(const std::string & default_app_type,
                                     int argc,
                                     char ** argv,
                                     MPI_Comm comm_word = MPI_COMM_WORLD);

  template <typename T>
  void reg(const std::string & name);

  InputParameters getValidParams(const std::string & name);

  MooseAppPtr createShared(const std::string & app_type,
                           const std::string & name,
                           InputParameters parameters,
                           MPI_Comm COMM_WORLD_IN);

  const auto & registeredObjects() const { return _name_to_build_info; }

  bool isRegistered(const std::string & app_name) const
  {
    return _name_to_build_info.count(app_name);
  }

  std::size_t createdAppCount(const std::string & app_type) const;

  const AppFactoryBuildInfoMap & registeredObjectBuildInfos() const { return _name_to_build_info; }

  AppFactory(AppFactory const &) = delete;
  Registry & operator=(AppFactory const &) = delete;

  AppFactory(AppFactory &&) = delete;
  Registry & operator=(AppFactory &&) = delete;

protected:
  AppFactoryBuildInfoMap _name_to_build_info;

private:
  // Private constructor for singleton pattern
  AppFactory() {}
};

template <typename T>
void
AppFactory::reg(const std::string & name)
{
  if (isRegistered(name))
    return;

  _name_to_build_info[name] = std::make_unique<AppFactoryBuildInfo<T>>();
}