Method expand_element_n_times

graphlite/src/exec/executor.rs:6568–6662

Expand an element exactly n times

(
        &self,
        start_path: &[String],
        element: &PathElement,
        path_type: &PathType,
        graph: &Arc<GraphCache>,
        visited_nodes: &mut std::collections::HashSet<Stri

    /// Expand an element exactly n times
    fn expand_element_n_times(
        &self,
        start_path: &[String],
        element: &PathElement,
        path_type: &PathType,
        graph: &Arc<GraphCache>,
        visited_nodes: &mut std::collections::HashSet<String>,
        visited_edges: &mut std::collections::HashSet<String>,
        n: u32,
    ) -> Result<Vec<Vec<String>>, ExecutionError> {
        if n == 0 {
            return Ok(vec![start_path.to_vec()]);
        }

        let mut current_paths = vec![start_path.to_vec()];

        for _ in 0..n {
            let mut new_paths = Vec::new();

            for path in current_paths {
                let current_node_id = path.last().unwrap();

                // Get edges based on direction
                let edges = match element.direction {
                    EdgeDirection::Outgoing => graph.get_outgoing_edges(current_node_id),
                    EdgeDirection::Incoming => graph.get_incoming_edges(current_node_id),
                    EdgeDirection::Both | EdgeDirection::Undirected => {
                        graph.get_connected_edges(current_node_id)
                    }
                };

                // Filter edges by label if specified
                let filtered_edges: Vec<_> = if element.edge_labels.is_empty() {
                    edges
                } else {
                    edges
                        .into_iter()
                        .filter(|e| element.edge_labels.contains(&e.label))
                        .collect()
                };

                // Check each edge for path type constraints
                for edge in filtered_edges {
                    let next_node_id = match element.direction {
                        EdgeDirection::Outgoing => &edge.to_node,
                        EdgeDirection::Incoming => &edge.from_node,
                        EdgeDirection::Both | EdgeDirection::Undirected => {
                            if edge.from_node == *current_node_id {
                                &edge.to_node
                            } else {
                                &edge.from_node
                            }
                        }
                    };

                    // Check path type constraints
                    let is_valid = match path_type {
                        PathType::Walk => true, // No constraints