computational_node.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 COMPUTATIONAL_NODE_H
#define COMPUTATIONAL_NODE_H
 
#include <string>
#include <map>
 
class ComputationalNode {
public:
 
    enum NodeType {
        Input, 
        Output, 
        Functional 
    };
 
    const static std::map<NodeType, std::string> nodeTypeStr;
 
    ComputationalNode() = delete;
    virtual ~ComputationalNode() = default;
 
    ComputationalNode(std::string id, NodeType type) :
    _id(std::move(id)),
    _type(type)
    { }
 
    const std::string& id() const
    { return this->_id; }
 
    NodeType type() const
    { return this->_type; }
 
    virtual std::string typeStr() const
    { return this->nodeTypeStr.at(this->type()); }
 
    void setVisited(bool visited)
    { this->_visited = visited; }
 
    bool isVisited() const
    { return this->_visited; }
 
    void setDoCompute(bool doCompute)
    { _doCompute = doCompute; }
 
    virtual bool doCompute() const
    { return _doCompute; }
 
    static std::pair<std::string, std::string> parseNodeAddress(const std::string& address, bool hasPort = true)
    {
        if(address.at(0) != '/')
            throw std::invalid_argument("Error while parsing node address \""+ address +"\". Computational Graph addresses must start with '/'");
 
        auto n = address.find('/',1);
        if(n == std::string::npos && hasPort)
            throw std::invalid_argument("Error while parsing node address \""+ address +"\". Expected format is '/node_id/port_id'");
 
        auto node = hasPort ? address.substr(1, n-1) : address.substr(1);
        auto port = hasPort ? address.substr(n+1, address.size()) : node;
 
        return std::make_pair(node, port);
    }
 
protected:
 
    virtual void configure() = 0;
 
    virtual void compute() = 0;
 
    virtual void graphCycleStartCB()
    { }
 
    virtual void graphLoadedCB()
    { }
 
    friend class ComputationalGraph;
    friend class ComputationalGraphManager;
    friend class ComputationalGraphPythonNodes_PYTHON_DECORATORS_BASIC_Test;
 
private:
 
    std::string _id;
    NodeType _type;
    bool _visited = false;
    bool _doCompute = false;
};
 
#endif //COMPUTATIONAL_NODE_H