AppFactory.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 <vector>
 
#include "MooseApp.h"
 
#ifdef MOOSE_UNIT_TEST
#include "gtest/gtest.h"
class GTEST_TEST_CLASS_NAME_(AppFactoryTest, manageAppParams);
class GTEST_TEST_CLASS_NAME_(AppFactoryTest, appCopyConstructParams);
class GTEST_TEST_CLASS_NAME_(AppFactoryTest, createNotRegistered);
#endif
 
#define registerApp(name) AppFactory::instance().reg<name>(#name)
 
struct AppFactoryBuildInfoBase
{
  virtual std::unique_ptr<MooseApp> 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 std::unique_ptr<MooseApp> build(const InputParameters & params) override
  {
    return std::make_unique<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 const std::string main_app_name;
 
  static std::unique_ptr<MooseApp> create(const std::string & app_type,
                                          const std::vector<std::string> & cli_args = {});
 
  static std::unique_ptr<MooseApp> create(std::unique_ptr<Parser> parser,
                                          std::unique_ptr<CommandLine> command_line);
 
  std::unique_ptr<MooseApp> create(const std::string & app_type,
                                   const std::string & name,
                                   InputParameters parameters,
                                   MPI_Comm COMM_WORLD_IN);
  std::shared_ptr<MooseApp> createShared(const std::string & app_type,
                                         const std::string & name,
                                         InputParameters parameters,
                                         MPI_Comm COMM_WORLD_IN);
 
  static std::shared_ptr<MooseApp> 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);
 
  const InputParameters & getAppParams(const InputParameters & params) const;
 
  class ClearAppParamsKey
  {
    friend class MooseApp;
#ifdef MOOSE_UNIT_TEST
    FRIEND_TEST(::AppFactoryTest, manageAppParams);
#endif
    ClearAppParamsKey() {}
    ClearAppParamsKey(const ClearAppParamsKey &) {}
  };
 
  void clearAppParams(const InputParameters & params, const ClearAppParamsKey);
 
  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:
  const InputParameters & storeAppParams(InputParameters & params);
 
  std::size_t getAppParamsID(const InputParameters & params) const;
 
  void registerAppCapability(const std::string & app_name);
 
  AppFactory() {}
 
#ifdef MOOSE_UNIT_TEST
  FRIEND_TEST(::AppFactoryTest, manageAppParams);
  FRIEND_TEST(::AppFactoryTest, appCopyConstructParams);
  FRIEND_TEST(::AppFactoryTest, createNotRegistered);
#endif
 
  std::map<std::size_t, std::unique_ptr<InputParameters>> _input_parameters;
};
 
template <typename T>
void
AppFactory::reg(const std::string & name)
{
  if (isRegistered(name))
    return;
 
  _name_to_build_info[name] = std::make_unique<AppFactoryBuildInfo<T>>();
 
  registerAppCapability(name);
}