function_manager.h

Go to the documentation of this file.

/* * NRP Core - Backend infrastructure to synchronize simulations
 *
 * Copyright 2020-2023 NRP Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * This project has received funding from the European Union’s Horizon 2020
 * Framework Programme for Research and Innovation under the Specific Grant
 * Agreement No. 945539 (Human Brain Project SGA3).
 */
 
#ifndef FUNCTION_MANAGER_H
#define FUNCTION_MANAGER_H
 
#include "nrp_general_library/engine_interfaces/engine_client_interface.h"
#include "nrp_general_library/transceiver_function/transceiver_datapack_interface.h"
#include "nrp_general_library/transceiver_function/from_engine_datapack.h"
 
#include <vector>
#include <map>
#include <memory>
#include <list>
#include <boost/python.hpp>
 
struct FunctionData
{
    std::string Name;
 
    TransceiverDataPackInterface::shared_ptr Function = nullptr;
 
    datapack_identifiers_set_t DataPackIDs;
 
    FunctionData() = default;
    FunctionData(const std::string &name,
                 const TransceiverDataPackInterface::shared_ptr &function,
                 const datapack_identifiers_set_t &datapackIDs);
};
 
 
class FunctionManager
{
    public:
 
        using function_datas_t = std::multimap<std::string, FunctionData>;
        using linked_functions_t = std::pair<FunctionManager::function_datas_t::iterator, FunctionManager::function_datas_t::iterator>;
        using status_function_results_t = std::tuple<bool, datapacks_vector_t>;
 
        FunctionManager();
        FunctionManager(const boost::python::dict &tfGlobals);
 
        datapack_identifiers_set_t getRequestedDataPackIDs() const;
 
        DataPackPassingPolicy getDataPackPassingPolicy() const;
 
        void setDataPackPassingPolicy(DataPackPassingPolicy method);
 
        void setSimulationTime(SimulationTime simulationTime);
 
        const SimulationTime & getSimulationTime() const;
 
        void setSimulationIteration(unsigned long simulationIteration);
 
        unsigned long getSimulationIteration() const;
 
        void loadDataPackFunction(const std::string & dataPackFunctionName, const std::string & dataPackFunctionFilename);
 
        void loadStatusFunction(const std::string & statusFunctionName, const std::string & statusFunctionFilename);
 
        datapacks_vector_t executePreprocessingFunctions(const std::string &engineName, datapacks_set_t dataPacks);
 
        datapacks_vector_t executeTransceiverFunctions(const std::string &engineName, datapacks_set_t dataPacks);
 
        status_function_results_t executeStatusFunction(datapacks_set_t dataPacks);
 
    private:
        // TODO Why does this return a pointer to pointer?
        TransceiverDataPackInterfaceSharedPtr *registerNewDataPackFunction(const std::string &linkedEngine, const TransceiverDataPackInterfaceSharedPtr &transceiverFunction);
 
        SimulationTime _simulationTime = SimulationTime::zero();
        unsigned long _simulationIteration = 0;
        DataPackPassingPolicy _DataPackPassingPolicy;
 
        // TODO Why does this return a pointer to pointer?
        TransceiverDataPackInterfaceSharedPtr *registerNewStatusFunction(const TransceiverDataPackInterfaceSharedPtr &statusFunction);
 
        boost::python::dict _globalDict;
 
        function_datas_t _dataPackFunctions;
 
        std::unique_ptr<FunctionData> _statusFunction = nullptr;
 
        function_datas_t::iterator _newDataPackFunctionIt = this->_dataPackFunctions.end();
 
        function_datas_t::const_iterator findDataPackFunction(const std::string &name) const;
 
        std::vector<std::shared_ptr<DataPackInterface>> runDataPackFunction(const std::string &tfName, datapacks_set_t dataPacks);
 
        linked_functions_t getDataPackFunctions(const std::string &engineName);
 
        datapacks_vector_t executeDataPackFunctions(const std::string &engineName,
                                                    datapacks_set_t dataPacks,
                                                    const bool preprocessing);
 
        // Give the function classes access to private methods,
        // so that they can register themselves in the manager
 
        friend class TransceiverFunction;
        friend class PreprocessingFunction;
        friend class StatusFunction;
};
 
using FunctionManagerSharedPtr = std::shared_ptr<FunctionManager>;
using FunctionManagerConstSharedPtr = std::shared_ptr<const FunctionManager>;
 
#endif // FUNCTION_MANAGER_H
 
// EOF