Method parse

src/onnx/parse_if.cpp:52–131

    }

    std::vector<instruction_ref> parse(const op_desc& /*opd*/,
                                       onnx_parser& parser,
                                       const onnx_parser::node_info& info,
                                       std::vector<instruction_ref> args) const
    {
        const auto& then_graph = info.attributes.at("then_branch").g();
        const auto& else_graph = info.attributes.at("else_branch").g();

        if(args.front()->get_shape().elements() != 1)
        {
            MIGRAPHX_THROW("PARSE_IF: " + info.name +
                           " condition input can have only one element!");
        }

        // Fold instruction if condition is constant thus can be evaled
        // prior to inference
        if(args.front()->can_eval())
        {
            auto cond_arg = args.front()->eval();
            auto* mod     = info.mod;
            // then branch
            if(cond_arg.at<bool>())
            {
                return parser.parse_graph(mod, then_graph, true);
            }
            // else branch
            else
            {
                return parser.parse_graph(mod, else_graph, true);
            }
        }

        std::string then_name = info.name + "_if";
        module_ref then_mdl   = parser.prog.create_module(then_name);

        std::string else_name = info.name + "_else";
        module_ref else_mdl   = parser.prog.create_module(else_name);

        // parse the then sub_graph
        (void)parser.parse_graph(then_mdl, then_graph);

        // parse_the else sub_graph
        (void)parser.parse_graph(else_mdl, else_graph);

        auto then_out_shapes = then_mdl->get_output_shapes();
        auto else_out_shapes = else_mdl->get_output_shapes();
        if(not std::equal(then_out_shapes.begin(),
                          then_out_shapes.end(),
                          else_out_shapes.begin(),
                          else_out_shapes.end()))
        {
            if(not std::equal(then_out_shapes.begin(),
                              then_out_shapes.end(),
                              else_out_shapes.begin(),
                              else_out_shapes.end(),
                              [](const shape& then_s, const shape& else_s) {
                                  return then_s.as_standard() == else_s.as_standard();
                              }))