Manage different tasks of writing out data from a source in a uniform yet flexible way. This is a class which, when being supplied with appropriate callables, manages their execution. More...

#include <data_manager.hh>

Public Types
using	Self = DataManager< Traits >
	Alias for own type.

using	Task = typename Traits::Task
	Task type, as defined in the traits.

using	Decider = typename Traits::Decider
	Decider type, as defined in the traits.

using	Trigger = typename Traits::Trigger
	Trigger type, as defined in the traits.

using	ExecutionProcess = typename Traits::ExecutionProcess
	Execution process type, as defined in the traits.

using	TaskMap = std::unordered_map< std::string, std::shared_ptr< Task > >
	Map of task names to shared pointers of Tasks; supporting polymorphism.

using	OrderedTaskMap = std::map< std::string, std::shared_ptr< Task > >
	Same as TaskMap, but using std::map such that ordering is preserved.

using	DeciderMap = std::unordered_map< std::string, std::shared_ptr< Decider > >
	Map of decider names to decider functions.

using	OrderedDeciderMap = std::map< std::string, std::shared_ptr< Decider > >
	Same as DeciderMap, but using std::map such that ordering is preserved.

using	TriggerMap = std::unordered_map< std::string, std::shared_ptr< Trigger > >
	Map of trigger names to trigger functions.

using	OrderedTriggerMap = std::map< std::string, std::shared_ptr< Trigger > >
	Same as TriggerMap, but using std::map such that ordering is preserved.

using	AssocsMap = std::unordered_map< std::string, std::vector< std::string > >
	Map of decider/task names to a collection of task names.

Public Member Functions
template<class Model , typename... Args>
void	operator() (Model &&model, Args &&... args)
	Invoke the execution process.

DeciderMap &	get_deciders ()
	Get the container of decider objects.

TaskMap &	get_tasks ()
	Get the container of task objects.

TriggerMap &	get_triggers ()
	Get the container of trigger objects.

AssocsMap &	get_decider_task_map ()
	Get the decider task map object.

AssocsMap &	get_trigger_task_map ()
	Get the trigger task map object.

const std::shared_ptr< spdlog::logger > &	get_logger () const
	Get the logger used in this DataManager.

	DataManager ()=default
	Construct a new Data Manager object.

	DataManager (const DataManager &other)=default
	Construct a new Data Manager object.

	DataManager (DataManager &&other)=default
	Construct a new Data Manager object.

DataManager &	operator= (const DataManager &other)=default
	Copy assignment.

DataManager &	operator= (DataManager &&other)=default
	Move assignment.

virtual	~DataManager ()=default
	Destroy the Data Manager object.

	DataManager (const Config &cfg, TaskMap tasks, std::unordered_map< std::string, std::function< std::shared_ptr< Decider >() > > deciders, std::unordered_map< std::string, std::function< std::shared_ptr< Trigger >() > > triggers, ExecutionProcess execproc)
	Construct DataManager using a config node.

	DataManager (OrderedTaskMap tasks, OrderedDeciderMap deciders, OrderedTriggerMap triggers, ExecutionProcess execproc, std::map< std::string, std::string > decider_task_assocs={}, std::map< std::string, std::string > trigger_task_assocs={})
	Construct DataManager without config node from passed mappings only. If the last two arguments are not given, it is assumed that tasks, deciders, triggers are of equal length and are to be associated in a one-to-one way in the order given. This order dependencey is also the reason why we make use of 'OrderedTaskMap' (an std::map) here.

void	swap (DataManager &other)
	Exchange the state of the caller with the argument 'other'.

Protected Member Functions
template<typename ObjMap , typename KnownObjectsMap >
ObjMap	_setup_from_config (const Config &cfg, KnownObjectsMap &&known_objects)

TaskMap	_filter_tasks_from_config (const Config &task_cfg, TaskMap &tasks)
	Check which tasks supplied to the datamanager are active and shall be retained, using the config node provided.

template<typename DTMap >
AssocsMap	_associate_from_config (const Config &task_cfg, DTMap &&dt_map, std::string lookup_key)
	Given a configuration, builds an association map.

Protected Attributes
std::shared_ptr< spdlog::logger >	_log
	Used to inform about progress of DataManager operations.

TaskMap	_tasks
	Stores (name, task) pairs in an unordered map.

DeciderMap	_deciders
	Stores (name, deciderfunction) pairs in an unordered map.

TriggerMap	_triggers
	Stores (name, triggerfunction) pairs in an unordered map.

AssocsMap	_decider_task_map
	Mapping from deciders names to containers of names of tasks that use those deciders.

AssocsMap	_trigger_task_map
	Mapping from trigger names to containers of names of tasks that use those triggers.

ExecutionProcess	_execution_process
	Callable which tells how to utilize triggers, deciders, tasks to write data.

Detailed Description

template<class Traits>
class Utopia::DataIO::DataManager< Traits >

Manage different tasks of writing out data from a source in a uniform yet flexible way. This is a class which, when being supplied with appropriate callables, manages their execution.

Idea

The entire process of writing data from a source to a location consists of deciding when to write, deciding when to switch location (making sure the respective location exists) and then actually writing data. The DataManager handles multiple independent instances of this process. In that sence, it works like an STL stream.

Implementation

The decision of when to write is handled by a callable which can be evaluated in an if clause context. This is called a "decider". How this works is user defined. All deciders have to have the same call signature. All deciders need to have a common base type.
The decision of when to switch/built a new location to write to is handled by a callable which can be evaluated in an if clause context. This is called a "trigger". How this works is user defined. All trigges need to have a common base type.
The process of writing out data to the appropriate location is handled by a class/struct which supplies the means to do this. This is called a "write task" or short: "task". A task hence has to supply the means to produce a new location to write to, and the means to receive data and write them to this location. How this works is user defined. Usually, the ::WriteTask class is enough for our context of writing data to HDF5 files with attributes. All tasks need to have a common base type.
Each decider is associated with one or more tasks.
Each trigger is associated with one or more tasks.
The actual execution of all data writing processes is handled by one and only one callable, the so-called "execution process". This has to at least be able to receive a reference to a DataManager instance, a reference to an object being a source of data (the model), and optionally an arbitrary number of additional arguments.

The details of all these callables/classes are implementation defined and up to the user.

Template Parameters

Traits A ::DataManagerTraits-like type. Supplies all customaizable types for the DataManager, i.e. the decider, trigger, task, and execution process.

Member Typedef Documentation

◆ AssocsMap

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::AssocsMap = std::unordered_map< std::string, std::vector< std::string > >

Map of decider/task names to a collection of task names.

◆ Decider

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::Decider = typename Traits::Decider

Decider type, as defined in the traits.

◆ DeciderMap

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::DeciderMap = std::unordered_map< std::string, std::shared_ptr< Decider > >

Map of decider names to decider functions.

◆ ExecutionProcess

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::ExecutionProcess = typename Traits::ExecutionProcess

Execution process type, as defined in the traits.

◆ OrderedDeciderMap

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::OrderedDeciderMap = std::map< std::string, std::shared_ptr< Decider > >

Same as DeciderMap, but using std::map such that ordering is preserved.

◆ OrderedTaskMap

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::OrderedTaskMap = std::map< std::string, std::shared_ptr< Task > >

Same as TaskMap, but using std::map such that ordering is preserved.

◆ OrderedTriggerMap

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::OrderedTriggerMap = std::map< std::string, std::shared_ptr< Trigger > >

Same as TriggerMap, but using std::map such that ordering is preserved.

◆ Self

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::Self = DataManager< Traits >

Alias for own type.

◆ Task

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::Task = typename Traits::Task

Task type, as defined in the traits.

◆ TaskMap

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::TaskMap = std::unordered_map< std::string, std::shared_ptr< Task > >

Map of task names to shared pointers of Tasks; supporting polymorphism.

◆ Trigger

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::Trigger = typename Traits::Trigger

Trigger type, as defined in the traits.

◆ TriggerMap

template<class Traits >

using Utopia::DataIO::DataManager< Traits >::TriggerMap = std::unordered_map< std::string, std::shared_ptr< Trigger > >

Map of trigger names to trigger functions.

Constructor & Destructor Documentation

◆ DataManager() [1/5]

template<class Traits >

Utopia::DataIO::DataManager< Traits >::DataManager ( )

default

Construct a new Data Manager object.

◆ DataManager() [2/5]

template<class Traits >

Utopia::DataIO::DataManager< Traits >::DataManager ( const DataManager< Traits > & other )

default

Construct a new Data Manager object.

Parameters

other Object to copy state from

◆ DataManager() [3/5]

template<class Traits >

Utopia::DataIO::DataManager< Traits >::DataManager ( DataManager< Traits > && other )

default

Construct a new Data Manager object.

Parameters

other Object to move state from

◆ ~DataManager()

template<class Traits >

virtual Utopia::DataIO::DataManager< Traits >::~DataManager ( )

virtualdefault

Destroy the Data Manager object.

◆ DataManager() [4/5]

template<class Traits >

Utopia::DataIO::DataManager< Traits >::DataManager	(	const Config &	cfg,
		TaskMap	tasks,
		std::unordered_map< std::string, std::function< std::shared_ptr< Decider >() > >	deciders,
		std::unordered_map< std::string, std::function< std::shared_ptr< Trigger >() > >	triggers,
		ExecutionProcess	execproc
	)

inline

Construct DataManager using a config node.

Arguments are an unordered_map that assigns names to shared_ptrs of tasks, and two other unordered_maps that assign names to factory functions for producing shared_ptrs to Deciders and triggers. This factory function approach enables us to use dynamic polymorphism on the deciders and triggers. This ability is not useful for tasks however, because they are designed to receive their functionality from the outside via passing them function objects on construction. Hence it is forgone here.

Parameters

cfg	Configuration node that contains datamanager config options
tasks	unordered_map containing name->shared_ptr_to_task mapping
deciders	map associating names to factory functions producing shared_ptr_to_deciders
triggers	map associating names to factory functions producing shared_ptr_to_triggers
execproc	Function object that determines the execution process of the datamanager, i.e., how the deciders, triggers and tasks work together to produce the output data

                                   :
        // Get the global data manager logger
        _log(spdlog::get("data_mngr")),
        _tasks(_filter_tasks_from_config(cfg["tasks"], tasks)),
        _deciders(_setup_from_config< DeciderMap >(cfg["deciders"], deciders)),
        _triggers(_setup_from_config< TriggerMap >(cfg["triggers"], triggers)),
        // Create maps: decider/trigger -> vector of task names
        _decider_task_map(
            _associate_from_config(cfg["tasks"], _deciders, "decider")),
        _trigger_task_map(
            _associate_from_config(cfg["tasks"], _triggers, "trigger")),
        _execution_process(execproc)
    {
        // nothing remains to be done here
    }

◆ DataManager() [5/5]

template<class Traits >

Utopia::DataIO::DataManager< Traits >::DataManager	(	OrderedTaskMap	tasks,
		OrderedDeciderMap	deciders,
		OrderedTriggerMap	triggers,
		ExecutionProcess	execproc,
		std::map< std::string, std::string >	decider_task_assocs = `{}`,
		std::map< std::string, std::string >	trigger_task_assocs = `{}`
	)

inline

Construct DataManager without config node from passed mappings only. If the last two arguments are not given, it is assumed that tasks, deciders, triggers are of equal length and are to be associated in a one-to-one way in the order given. This order dependencey is also the reason why we make use of 'OrderedTaskMap' (an std::map) here.

Parameters

tasks	map that assigns names to shared_ptrs to tasks
deciders	map that assigns names to shared_ptrs to deciders
triggers	map that assigns names to shared_ptrs to triggers
execproc	Function object that determines the execution process of the datamanager, i.e., how the deciders, triggers and tasks work together to produce the the output data
decider_task_assocs	Map that assigns each task a decider function by name: taskname->decidername
trigger_task_assocs	Map that assigns each task a trigger function by name: taskname->triggername

                                                                     {},
                std::map< std::string, std::string > trigger_task_assocs = {}) :
        // Get the global data manager logger
        _log(spdlog::get("data_mngr")),
        _tasks(TaskMap(tasks.begin(), tasks.end())),
        _deciders(DeciderMap(deciders.begin(), deciders.end())),
        _triggers(TriggerMap(triggers.begin(), triggers.end())),
        // Create maps: decider/trigger -> vector of task names
        _decider_task_map(_DMUtils::build_task_association_map< AssocsMap >(
            tasks, deciders, decider_task_assocs)),
        _trigger_task_map(_DMUtils::build_task_association_map< AssocsMap >(
            tasks, triggers, trigger_task_assocs)),
        _execution_process(execproc)
    {
        _log->info("DataManager setup with {} task(s), {} decider(s), and "
                   "{} trigger(s).",
                   _tasks.size(),
                   _decider_task_map.size(),
                   _trigger_task_map.size());
    }

Member Function Documentation

◆ _associate_from_config()

template<class Traits >

template<typename DTMap >

AssocsMap Utopia::DataIO::DataManager< Traits >::_associate_from_config	(	const Config &	task_cfg,
		DTMap &&	dt_map,
		std::string	lookup_key
	)

inlineprotected

Given a configuration, builds an association map.

Template Parameters

DTMap automatically determined

Parameters

task_cfg	The mapping to iterate as given by the config. It holds the tasks and names the decider and trigger and the task is associated to and tells if it is active or not.
dt_map	Map that holds names->decider/trigger mapping. Used to check if the names in the config indeed match some known decider/trigger.
lookup_key	Key which names the mapping used for association, i.e., "decider" or "trigger".

Returns: AssocsMap Map that associates the given deciders/triggers with a vector of names that name tasks.

    {
        AssocsMap map;
 
        // error checking regarding the task_cfg node is done in the
        // _filter_tasks function, and hence does not need to be repeated here
 
        _log->debug("Building task to {} associations from given config ...",
                    lookup_key);
 
        // Iterate over the given configuration node, pull out the name of the
        // task and the name of the associated decider/trigger, and put the
        // AssocsMap together from this
        for (const auto& node_pair : task_cfg)
        {
            // Unpack the (key node, value node) pair
            const auto  task_name = node_pair.first.as< std::string >();
            const auto& task_cfg  = node_pair.second;
 
            // Find out if active; true by default
            const auto active = get_as< bool >("active", task_cfg, true);
 
            // Associate only if active
            if (not active)
            {
                _log->debug("Task '{}' was marked as not active; skipping.",
                            task_name);
                continue;
            }
 
            // Get the name of the trigger or decider to associate to
 
            const auto dt_to_associate_to =
                get_as< std::string >(lookup_key, task_cfg);
 
            // Find erroneous config namings for deciders/triggers
            if (dt_map.find(dt_to_associate_to) == dt_map.end())
            {
                this->_log->info(" Error for decider/trigger: {}",
                                 dt_to_associate_to);
                throw std::invalid_argument(
                    "Error when trying to associate tasks to deciders or "
                    "triggers: "
                    "Name in config does not match the name of a "
                    "decider/trigger known to the datamanager");
            }
            else
            {
                // dt_to_associate_to exists in the dt_map, we're good
                map[dt_to_associate_to].push_back(task_name);
 
                _log->debug("Associating task '{}' to {} '{}'.",
                            task_name,
                            lookup_key,
                            dt_to_associate_to);
            }
        }
 
        // Use the helper function to build the actual association map
        return map;
    }

◆ _filter_tasks_from_config()

template<class Traits >

TaskMap Utopia::DataIO::DataManager< Traits >::_filter_tasks_from_config	(	const Config &	task_cfg,
		TaskMap &	tasks
	)

inlineprotected

Check which tasks supplied to the datamanager are active and shall be retained, using the config node provided.

Parameters

task_cfg	config node defining tasks
tasks	unordered map naming pointers to tasks

Returns: TaskMap 'tasks' map filtered by activity

    {
        // map to use in the end
        TaskMap map;
 
        if (not task_cfg)
        {
            throw std::invalid_argument(
                "Error: data_manager config node needs to contain a node "
                "'tasks' which it apparently is missing ");
        }
        if (not task_cfg.IsMap())
        {
            throw std::invalid_argument("Expected a mapping for DataManager "
                                        "task filtering, got:\n" +
                                        to_string(task_cfg));
        }
 
        for (const auto& node_pair : task_cfg)
        {
            // Unpack the (key node, value node) pair, i.e. the name of the
            // object that is to be configured and the corresponding
            // configuration node
            const auto  cfg_name = node_pair.first.as< std::string >();
            const auto& obj_cfg  = node_pair.second;
 
            _log->debug("Investigating task {} and checking if it is active ",
                        cfg_name);
 
            if (get_as< bool >("active", obj_cfg))
            {
 
                _log->debug("Task '{}' was marked as active; will be kept.",
                            cfg_name);
 
                if (tasks.find(cfg_name) == tasks.end())
                {
                    throw std::invalid_argument(
                        "Error, no task supplied to the datamanager is named " +
                        cfg_name);
                }
                else
                {
                    map[cfg_name] = tasks[cfg_name];
                }
            }
            else
            {
                // skip inactive tasks
                _log->debug("Task '{}' was marked as not active; skipping.",
                            cfg_name);
                continue;
            }
        }
 
        return map;
    }

◆ _setup_from_config()

template<class Traits >

template<typename ObjMap , typename KnownObjectsMap >

ObjMap Utopia::DataIO::DataManager< Traits >::_setup_from_config	(	const Config &	cfg,
		KnownObjectsMap &&	known_objects
	)

inlineprotected

    {
        _log->debug("Setting up name -> object map from config node ...");
 
        // Check whether the given configuration is valid
        if (not cfg)
        {
            throw std::invalid_argument("Received a zombie node for the setup "
                                        "of DataManager objects!");
        }
        else if (not cfg.IsMap())
        {
            throw std::invalid_argument("Expected a mapping for DataManager "
                                        "object setup, got:\n" +
                                        to_string(cfg));
        }
 
        // The name -> object map that is to be populated
        ObjMap map;
        _log->debug("Configuring DataManager objects ... (container size: {})",
                    known_objects.size());
 
        // Go over the known objects and decide whether to retain them
        // as they are or whether new objects need to be constructed from the
        // known ones
        // Depending on the name of the object, the name given in the
        // configuration, and the configuration itself, decide on
        // whether a new object needs to be constructed or can be
        // retained from the known objects.
        // If the configuration specifies a type, use that information
        // to either construct a new object from given arguments or
        // copy-construct one from an existing object
        for (const auto& node_pair : cfg)
        {
            // Unpack the (key node, value node) pair, i.e. the name of the
            // object that is to be configured and the corresponding
            // configuration node
            const auto  cfg_name = node_pair.first.as< std::string >();
            const auto& obj_cfg  = node_pair.second;
 
            const auto type_name = get_as< std::string >("type", obj_cfg);
 
            _log->debug("Attempting to build {} of type {} from config",
                        cfg_name,
                        type_name);
 
            if (known_objects.find(type_name) == known_objects.end())
            {
                throw std::invalid_argument("Error for node " + cfg_name +
                                            ": No 'type' node given");
            }
            else
            {
                if (obj_cfg["args"])
                {
                    _log->debug("  ... using given arguments from config ...");
                    map[cfg_name] =
                        known_objects[type_name](); // default construct
                    map[cfg_name]->set_from_cfg(obj_cfg["args"]);
                }
                else
                {
 
                    // if no args is given, do a default build because this
                    // not all of the deciders/triggers need an args node
                    _log->debug("... constructing {} of type {} without "
                                "config args because no node 'args' is "
                                "given for it in the config.",
                                cfg_name,
                                type_name);
 
                    map[cfg_name] = known_objects[type_name]();
                }
            }
        }
 
        return map;
    }

◆ get_decider_task_map()

template<class Traits >

AssocsMap & Utopia::DataIO::DataManager< Traits >::get_decider_task_map ( )

inline

Get the decider task map object.

Returns: const AssocsMap&

    {
        return _decider_task_map;
    }

◆ get_deciders()

template<class Traits >

DeciderMap & Utopia::DataIO::DataManager< Traits >::get_deciders ( )

inline

Get the container of decider objects.

Returns: const DeciderMap&

    {
        return _deciders;
    }

◆ get_logger()

template<class Traits >

const std::shared_ptr< spdlog::logger > & Utopia::DataIO::DataManager< Traits >::get_logger ( ) const

inline

Get the logger used in this DataManager.

Returns: const std::shared_ptr<spdlog::logger>&

    {
        return _log;
    }

◆ get_tasks()

template<class Traits >

TaskMap & Utopia::DataIO::DataManager< Traits >::get_tasks ( )

inline

Get the container of task objects.

Returns: const TaskMap&

    {
        return _tasks;
    }

◆ get_trigger_task_map()

template<class Traits >

AssocsMap & Utopia::DataIO::DataManager< Traits >::get_trigger_task_map ( )

inline

Get the trigger task map object.

Returns: const AssocsMap&

    {
        return _trigger_task_map;
    }

◆ get_triggers()

template<class Traits >

TriggerMap & Utopia::DataIO::DataManager< Traits >::get_triggers ( )

inline

Get the container of trigger objects.

Returns: const TriggerMap&

    {
        return _triggers;
    }

◆ operator()()

template<class Traits >

template<class Model , typename... Args>

void Utopia::DataIO::DataManager< Traits >::operator()	(	Model &&	model,
		Args &&...	args
	)

inline

Invoke the execution process.

Template Parameters

Args	Parameter pack types

Parameters

model	The model reference to pass on to the execution process
args	The parameter pack to pass on to the execution process

    {
        _execution_process(
            *this, std::forward< Model >(model), std::forward< Args >(args)...);
    }

◆ operator=() [1/2]

template<class Traits >

DataManager & Utopia::DataIO::DataManager< Traits >::operator= ( const DataManager< Traits > & other )

default

Copy assignment.

Parameters

other

Returns: DataManager& reference to object to assign the state from.

◆ operator=() [2/2]

template<class Traits >

DataManager & Utopia::DataIO::DataManager< Traits >::operator= ( DataManager< Traits > && other )

default

Move assignment.

Parameters

other

Returns: DataManager& reference to object to assign the state from.

◆ swap()

template<class Traits >

void Utopia::DataIO::DataManager< Traits >::swap ( DataManager< Traits > & other )

inline

Exchange the state of the caller with the argument 'other'.

Parameters

other

    {
        if (this == &other)
        {
            return;
        }
 
        using std::swap;
        swap(_log, other._log);
        swap(_tasks, other._tasks);
        swap(_deciders, other._deciders);
        swap(_triggers, other._triggers);
        swap(_decider_task_map, other._decider_task_map);
        swap(_trigger_task_map, other._trigger_task_map);
    }

Member Data Documentation

◆ _decider_task_map

template<class Traits >

AssocsMap Utopia::DataIO::DataManager< Traits >::_decider_task_map

protected

Mapping from deciders names to containers of names of tasks that use those deciders.

◆ _deciders

template<class Traits >

DeciderMap Utopia::DataIO::DataManager< Traits >::_deciders

protected

Stores (name, deciderfunction) pairs in an unordered map.

◆ _execution_process

template<class Traits >

ExecutionProcess Utopia::DataIO::DataManager< Traits >::_execution_process

protected

Callable which tells how to utilize triggers, deciders, tasks to write data.

◆ _log

template<class Traits >

std::shared_ptr< spdlog::logger > Utopia::DataIO::DataManager< Traits >::_log

protected

Used to inform about progress of DataManager operations.

◆ _tasks

template<class Traits >

TaskMap Utopia::DataIO::DataManager< Traits >::_tasks

protected

Stores (name, task) pairs in an unordered map.

◆ _trigger_task_map

template<class Traits >

AssocsMap Utopia::DataIO::DataManager< Traits >::_trigger_task_map

protected

Mapping from trigger names to containers of names of tasks that use those triggers.

◆ _triggers

template<class Traits >

TriggerMap Utopia::DataIO::DataManager< Traits >::_triggers

protected

Stores (name, triggerfunction) pairs in an unordered map.

The documentation for this class was generated from the following file:

include/utopia/data_io/data_manager/data_manager.hh

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Idea

Implementation

Member Typedef Documentation

◆ AssocsMap

◆ Decider

◆ DeciderMap

◆ ExecutionProcess

◆ OrderedDeciderMap

◆ OrderedTaskMap

◆ OrderedTriggerMap

◆ Self

◆ Task

◆ TaskMap

◆ Trigger

◆ TriggerMap

Constructor & Destructor Documentation

◆ DataManager() [1/5]

◆ DataManager() [2/5]

◆ DataManager() [3/5]

◆ ~DataManager()

◆ DataManager() [4/5]

◆ DataManager() [5/5]

Member Function Documentation

◆ _associate_from_config()

◆ _filter_tasks_from_config()

◆ _setup_from_config()

◆ get_decider_task_map()

◆ get_deciders()

◆ get_logger()

◆ get_tasks()

◆ get_trigger_task_map()

◆ get_triggers()

◆ operator()()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ swap()

Member Data Documentation

◆ _decider_task_map

◆ _deciders

◆ _execution_process

◆ _log

◆ _tasks

◆ _trigger_task_map

◆ _triggers