ActionFactory.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 <map>
#include <set>
 
#include "Action.h" // Technically required for std::shared_ptr<Action>(Action*) constructor
#include "InputParameters.h"
#include "FileLineInfo.h"
 
#define registerSyntax(action, action_syntax)                                                      \
  syntax.registerActionSyntax(action, action_syntax, "", __FILE__, __LINE__)
#define registerSyntaxTask(action, action_syntax, task)                                            \
  syntax.registerActionSyntax(action, action_syntax, task, __FILE__, __LINE__)
#define registerDeprecatedSyntax(action, action_syntax, message)                                   \
  syntax.registerActionSyntax(action, action_syntax, "", __FILE__, __LINE__);                      \
  syntax.deprecateActionSyntax(action_syntax, message)
#define registerDeprecatedSyntaxTask(action, action_syntax, task, message)                         \
  syntax.registerActionSyntax(action, action_syntax, task, __FILE__, __LINE__);                    \
  syntax.deprecateActionSyntax(action_syntax, message)
#define registerTask(name, is_required) syntax.registerTaskName(name, is_required)
#define registerMooseObjectTask(name, moose_system, is_required)                                   \
  syntax.registerTaskName(name, stringifyName(moose_system), is_required)
#define appendMooseObjectTask(name, moose_system)                                                  \
  syntax.appendTaskName(name, stringifyName(moose_system), false)
#define appendDeprecatedMooseObjectTask(name, moose_system)                                        \
  syntax.appendTaskName(name, stringifyName(moose_system), true)
#define addTaskDependency(action, depends_on) syntax.addDependency(action, depends_on)
 
// Forward Declaration
class MooseApp;
 
class ActionFactory
{
public:
  ActionFactory(MooseApp & app);
 
  virtual ~ActionFactory();
 
  MooseApp & app() { return _app; }
 
  void reg(std::shared_ptr<RegistryEntryBase> obj);
 
  FileLineInfo getLineInfo(const std::string & name, const std::string & task) const;
 
  std::string getTaskName(const std::string & action);
 
  std::shared_ptr<Action>
  create(const std::string & action, const std::string & action_name, InputParameters & parameters);
 
  InputParameters getValidParams(const std::string & name);
 
  struct BuildInfo
  {
    std::shared_ptr<RegistryEntryBase> _obj_pointer;
    std::string _task;
  };
 
  typedef std::multimap<std::string, BuildInfo>::iterator iterator;
  typedef std::multimap<std::string, BuildInfo>::const_iterator const_iterator;
 
  iterator begin();
  const_iterator begin() const;
 
  iterator end();
  const_iterator end() const;
 
  std::pair<std::multimap<std::string, std::string>::const_iterator,
            std::multimap<std::string, std::string>::const_iterator>
  getActionsByTask(const std::string & task) const;
 
  std::set<std::string> getTasksByAction(const std::string & action) const;
 
  bool isRegisteredTask(const std::string & task) const { return _tasks.count(task); }
 
  const InputParameters * currentlyConstructing() const;
 
private:
  template <class T>
  static std::shared_ptr<Action> buildAction(const InputParameters & parameters)
  {
    return std::make_shared<T>(parameters);
  }
 
  MooseApp & _app;
 
  std::multimap<std::string, BuildInfo> _name_to_build_info;
 
  FileLineInfoMap _name_to_line;
  std::multimap<std::string, std::string> _task_to_action_map;
 
  std::set<std::pair<std::string, std::string>> _current_objs;
 
  std::set<std::string> _tasks;
 
  std::vector<const InputParameters *> _currently_constructing;
};