Function inline_operations

ciphercore-base/src/inline/inline_ops.rs:139–178

Creates a new context from the given context, recursively inlining operations in the main graph with accordance to the given InlineConfig. In case of inlined operations with graph dependencies, these graphs are recursively processed with the same config. The inlining process preserves node annotations and names of nodes in the main graph. The name of a to-be-inlined Call/Iterate node is passed to

(context: Context, config: InlineConfig)

/// The inlining process preserves node annotations and names of nodes in the main graph.
/// The name of a to-be-inlined Call/Iterate node is passed to a node containing its output.
pub fn inline_operations(context: Context, config: InlineConfig) -> Result<Context> {
    context.check_finalized()?;
    // First, collect all graphs reachable from the main graph which won't be
    // inlined.
    let mut graph_ids_to_process = HashSet::<u64>::new();
    let mut graph_ids_seen = HashSet::<u64>::new();
    let main_graph = context.get_main_graph()?;
    graph_ids_to_process.insert(main_graph.get_id());
    graph_ids_seen.insert(main_graph.get_id());
    collect_graphs(
        main_graph.clone(),
        config.clone(),
        &mut graph_ids_to_process,
        &mut graph_ids_seen,
    )?;
    let output_context = create_context()?;
    let mut inlining_context = InliningContext {
        config,
        context_mapping: ContextMappings::default(),
        ephemeral_context_mapping: ContextMappings::default(),
    };
    // Now, apply inlining to all of the collected graphs in the topological order.
    for graph in context.get_graphs() {
        if graph_ids_to_process.contains(&graph.get_id()) {
            let new_graph = output_context.create_graph()?;
            for annotation in graph.get_annotations()? {
                new_graph.add_annotation(annotation)?;
            }
            inlining_context.insert_graph(graph.clone(), new_graph.clone());
            let output_node =
                recursively_inline_graph(graph, new_graph.clone(), &mut inlining_context)?;
            new_graph.set_output_node(output_node)?;
            new_graph.finalize()?;
        }
    }

    output_context.set_main_graph(inlining_context.get_graph(main_graph))?;
    output_context.finalize()?;
    Ok(output_context)
}

/// Determines all subgraphs reachable from graph which won't be inlined.
fn collect_graphs(