DataflowGraph.hpp

#pragma once
#include <Dataflow/RaDataflow.hpp>
 
#include <Dataflow/Core/GraphNodes.hpp>
#include <Dataflow/Core/Node.hpp>
#include <Dataflow/Core/NodeFactory.hpp>
 
#include <Core/Types.hpp>
#include <Core/Utils/BijectiveAssociation.hpp>
#include <Core/Utils/Color.hpp>
#include <Core/Utils/Singleton.hpp>
 
#include <functional>
 
namespace Ra {
namespace Dataflow {
namespace Core {
 
class RA_DATAFLOW_CORE_API DataflowGraph : public Node
{
  public:
    explicit DataflowGraph( const std::string& name );
    virtual ~DataflowGraph() = default;
 
    void init() override;
    bool execute() override;
    void destroy() override;
 
    bool loadFromJson( const std::string& jsonFilePath );
 
    void saveToJson( const std::string& jsonFilePath );
 
    virtual bool add_node( std::shared_ptr<Node> newNode );
    template <typename T, typename... U>
    std::shared_ptr<T> add_node( U&&... u );
 
    virtual bool remove_node( std::shared_ptr<Node> node );
 
    bool add_link( const std::shared_ptr<Node>& nodeFrom,
                   const std::string& nodeFromOutputName,
                   const std::shared_ptr<Node>& nodeTo,
                   const std::string& nodeToInputName );
    bool add_link( const std::shared_ptr<Node>& nodeFrom,
                   Node::PortIndex portOutIdx,
                   const std::shared_ptr<Node>& nodeTo,
                   Node::PortIndex portInIdx );
    bool add_link( Node::PortBaseOutRawPtr outputPort, Node::PortBaseInRawPtr inputPort );
 
    template <typename T, typename U>
    bool add_link( const std::shared_ptr<PortOut<T>>& outputPort,
                   const std::shared_ptr<PortIn<U>>& inputPort );
 
    bool can_link( const std::shared_ptr<Node>& nodeFrom,
                   Node::PortIndex portOutIdx,
                   const std::shared_ptr<Node>& nodeTo,
                   Node::PortIndex portInIdx ) const;
 
    bool can_link( const Node* nodeFrom,
                   Node::PortIndex portOutIdx,
                   const Node* nodeTo,
                   Node::PortIndex portInIdx ) const;
 
    bool remove_link( std::shared_ptr<Node> node, const std::string& nodeInputName );
 
    bool remove_link( std::shared_ptr<Node> node, const PortIndex& in_port_index );
 
    const std::vector<std::shared_ptr<Node>>& nodes() const { return m_nodes; }
 
    std::shared_ptr<Node> node( const std::string& instanceNameNode ) const;
 
    template <typename T>
    std::shared_ptr<T> node( const std::string& instanceNameNode ) const {
        return std::dynamic_pointer_cast<T>( node( instanceNameNode ) );
    }
    std::shared_ptr<T> node( const std::string& instanceNameNode ) const  {…}
 
    const std::vector<std::vector<Node*>>& nodes_by_level() const { return m_nodes_by_level; }
 
    bool compile() override;
 
    void generate_ports();
 
    size_t node_count() const { return m_nodes.size(); }
 
    virtual void clear_nodes();
 
    bool is_compiled() const { return m_ready; }
 
    inline void needs_recompile();
 
    Node::PortBaseInRawPtr input_node_port( const std::string& nodeName,
                                            const std::string& portName );
    Node::PortBaseOutRawPtr output_node_port( const std::string& nodeName,
                                              const std::string& portName );
 
    bool shouldBeSaved() { return m_should_save; }
 
    static const std::string& node_typename();
 
    static std::shared_ptr<DataflowGraph> loadGraphFromJsonFile( const std::string& filename );
 
    void setNodesAndLinksProtection( bool on ) { m_nodesAndLinksProtected = on; }
 
    bool nodesAndLinksProtection() const { return m_nodesAndLinksProtected; }
 
    using Node::add_input;
    using Node::add_output;
 
    void add_input_output_nodes();
 
    void remove_unlinked_input_output_ports();
 
    std::shared_ptr<GraphOutputNode> output_node() { return m_output_node; }
    std::shared_ptr<GraphInputNode> input_node() { return m_input_node; }
 
  protected:
    DataflowGraph( const std::string& instanceName, const std::string& typeName );
 
    bool fromJsonInternal( const nlohmann::json& data ) override;
    void toJsonInternal( nlohmann::json& ) const override;
 
    bool has_node_by_name( const std::string& instance, const std::string& model ) const;
    bool contains_node_recursive( const Node* node ) const;
 
  private:
    // Internal helper functions
    void
    backtrack_graph( Node* current,
                     std::unordered_map<Node*, std::pair<int, std::vector<Node*>>>& infoNodes );
    int traverse_graph( Node* current,
                        std::unordered_map<Node*, std::pair<int, std::vector<Node*>>>& infoNodes );
 
    bool check_last_port_io_nodes( const Node* nodeFrom,
                                   Node::PortIndex portOutIdx,
                                   const Node* nodeTo,
                                   Node::PortIndex portInIdx ) const {
        if ( nodeFrom == m_input_node.get() && portOutIdx == m_input_node->outputs().size() )
            return true;
        if ( nodeTo == m_output_node.get() && portInIdx == m_output_node->inputs().size() )
            return true;
        return false;
    }
 
    bool are_nodes_valids( const Node* nodeFrom, const Node* nodeTo, bool verbose = false ) const;
    static bool are_ports_compatible( const Node* nodeFrom,
                                      const PortBaseOut* portOut,
                                      const Node* nodeTo,
                                      const PortBaseIn* portIn );
    class RA_DATAFLOW_CORE_API Log
    {
      public:
        static void already_linked( const Node* node, const PortBase* port );
        static void link_type_mismatch( const Node* nodeFrom,
                                        const PortBase* portOut,
                                        const Node* nodeTo,
                                        const PortBase* portIn );
        static void unable_to_find( const std::string& type, const std::string& instanceName );
        static void bad_port_index( const std::string& type,
                                    const std::string& instanceName,
                                    Node::PortIndex idx );
        static void try_to_link_input_to_output();
    };
 
    bool m_should_save { false };
 
    bool m_ready { false };
 
    std::vector<std::shared_ptr<Node>> m_nodes;
    std::shared_ptr<GraphOutputNode> m_output_node { nullptr };
    std::shared_ptr<GraphInputNode> m_input_node { nullptr };
 
    std::vector<std::vector<Node*>> m_nodes_by_level;
 
    bool m_nodesAndLinksProtected { false };
};
class RA_DATAFLOW_CORE_API DataflowGraph : public Node {…};
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
template <typename T, typename... U>
std::shared_ptr<T> DataflowGraph::add_node( U&&... u ) {
    auto ret = std::make_shared<T>( std::forward<U>( u )... );
    if ( add_node( ret ) ) return ret;
    return nullptr;
}
std::shared_ptr<T> DataflowGraph::add_node( U&&... u ) {…}
 
template <typename T, typename U>
bool DataflowGraph::add_link( const std::shared_ptr<PortOut<T>>& outputPort,
                              const std::shared_ptr<PortIn<U>>& inputPort ) {
    using namespace Ra::Core::Utils;
 
    static_assert( std::is_same_v<T, U>, "in and out port's types mismatch" );
 
    return add_link( outputPort.get(), inputPort.get() );
}
bool DataflowGraph::add_link( const std::shared_ptr<PortOut<T>>& outputPort, {…}
 
inline bool DataflowGraph::can_link( const std::shared_ptr<Node>& nodeFrom,
                                     Node::PortIndex portOutIdx,
                                     const std::shared_ptr<Node>& nodeTo,
                                     Node::PortIndex portInIdx ) const {
    return can_link( nodeFrom.get(), portOutIdx, nodeTo.get(), portInIdx );
}
inline bool DataflowGraph::can_link( const std::shared_ptr<Node>& nodeFrom, {…}
 
inline bool DataflowGraph::can_link( const Node* nodeFrom,
                                     Node::PortIndex portOutIdx,
                                     const Node* nodeTo,
                                     Node::PortIndex portInIdx ) const {
    auto portIn  = nodeTo->input_by_index( portInIdx );
    auto portOut = nodeFrom->output_by_index( portOutIdx );
 
    if ( !are_nodes_valids( nodeFrom, nodeTo ) ) { return false; }
    if ( check_last_port_io_nodes( nodeFrom, portOutIdx, nodeTo, portInIdx ) ) {
        if ( nodeFrom == m_input_node.get() ) return portIn != nullptr;
        if ( nodeTo == m_output_node.get() ) return portOut != nullptr;
    }
 
    // Compare types
    return portIn && portOut && ( portIn->type() == portOut->type() && !portIn->is_linked() );
}
inline bool DataflowGraph::can_link( const Node* nodeFrom, {…}
 
inline void DataflowGraph::needs_recompile() {
    m_should_save = true;
    m_ready       = false;
}
inline void DataflowGraph::needs_recompile() {…}
 
inline Node::PortBaseInRawPtr DataflowGraph::input_node_port( const std::string& nodeName,
                                                              const std::string& portName ) {
    auto n = node( nodeName );
    auto p = n->input_by_name( portName );
    CORE_ASSERT( p.first.isValid(), "invalid port, node: " + nodeName + " port: " + portName );
    return p.second;
}
inline Node::PortBaseInRawPtr DataflowGraph::input_node_port( const std::string& nodeName, {…}
 
inline Node::PortBaseOutRawPtr DataflowGraph::output_node_port( const std::string& nodeName,
                                                                const std::string& portName ) {
    auto n = node( nodeName );
    auto p = n->output_by_name( portName );
    CORE_ASSERT( p.first.isValid(), "invalid port, node: " + nodeName + " port: " + portName );
 
    return p.second;
}
inline Node::PortBaseOutRawPtr DataflowGraph::output_node_port( const std::string& nodeName, {…}
 
inline void DataflowGraph::add_input_output_nodes() {
    if ( !m_input_node ) { m_input_node = std::make_shared<GraphInputNode>( "input" ); }
    if ( !m_output_node ) { m_output_node = std::make_shared<GraphOutputNode>( "output" ); }
    m_input_node->set_graph( this );
    m_output_node->set_graph( this );
    add_node( m_input_node );
    add_node( m_output_node );
}
inline void DataflowGraph::add_input_output_nodes() {…}
 
inline void DataflowGraph::remove_unlinked_input_output_ports() {
    if ( m_input_node ) { m_input_node->remove_unlinked_ports(); }
    if ( m_output_node ) { m_output_node->remove_unlinked_ports(); }
    generate_ports();
}
inline void DataflowGraph::remove_unlinked_input_output_ports() {…}
 
inline const std::string& DataflowGraph::node_typename() {
    static std::string demangledTypeName { "Core DataflowGraph" };
    return demangledTypeName;
}
 
} // namespace Core
} // namespace Dataflow
} // namespace Ra