Function bfs

src/graph/algorithms/TopologicalSort.cpp:72–125

} // namespace detail

std::vector<NodeID> bfs(Graph &g)
{
    std::vector<NodeID> bfs_order_vector;

    // Created visited vector
    std::vector<bool> visited(g.nodes().size(), false);

    // Create BFS queue
    std::list<NodeID> queue;

    // Push inputs and mark as visited
    for (auto &input : g.nodes(NodeType::Input))
    {
        if (input != EmptyNodeID)
        {
            visited[input] = true;
            queue.push_back(input);
        }
    }

    // Push const nodes and mark as visited
    for (auto &const_node : g.nodes(NodeType::Const))
    {
        if (const_node != EmptyNodeID)
        {
            visited[const_node] = true;
            queue.push_back(const_node);
        }
    }

    // Iterate over vector and edges
    while (!queue.empty())
    {
        // Dequeue a node from queue and process
        NodeID n = queue.front();
        bfs_order_vector.push_back(n);
        queue.pop_front();

        const INode *node = g.node(n);
        ARM_COMPUTE_ERROR_ON(node == nullptr);
        for (const auto &eid : node->output_edges())
        {
            const Edge *e = g.edge(eid);
            ARM_COMPUTE_ERROR_ON(e == nullptr);
            if (!visited[e->consumer_id()] && detail::all_inputs_are_visited(e->consumer(), visited))
            {
                visited[e->consumer_id()] = true;
                queue.push_back(e->consumer_id());
            }
        }
    }

    return bfs_order_vector;
}

std::vector<NodeID> dfs(Graph &g)
{