Struct traitgraph::implementation::subgraphs::induced_incremental_subgraph::InducedIncrementalSubgraph

pub struct InducedIncrementalSubgraph<'a, Graph: GraphBase> { /* private fields */ }

A subgraph that stores the presence or absence of a node using integers. Additionally, this subgraph has a current step that can be altered. Nodes are added with that step, and only nodes with a step lower or equal to the current one are counted as present. This allows to combine multiple subgraphs into one, if they are totally ordered by the subset relation.

In this variant of the incremental subgraph, edges are part of a subgraph if their endpoints are part of the subgraph.

Implementations

impl<'a, Graph: ImmutableGraphContainer> InducedIncrementalSubgraph<'a, Graph>

pub fn new_with_incremental_steps( graph: &'a Graph, incremental_steps: usize ) -> Self

Create an incremental subgraph with the given amount of incremental steps.

pub fn set_current_step(&mut self, current_step: usize)

Set the current incremental step of the graph.

pub fn new_nodes(&self) -> &Vec<Graph::NodeIndex>

Return the nodes that are added in the current incremental step.

pub fn is_new_node(&self, node_index: <Self as GraphBase>::NodeIndex) -> bool

Returns true if this node was added in the current step.

pub fn is_newly_removed_node( &self, node_index: <Self as GraphBase>::NodeIndex ) -> bool

Returns true if this node was removed in the current reverse step.

Trait Implementations

impl<Graph: GraphBase> GraphBase for InducedIncrementalSubgraph<'_, Graph>

type NodeData = <Graph as GraphBase>::NodeData

The data type associated with each node.

type EdgeData = <Graph as GraphBase>::EdgeData

The data type associated with each edge.

type OptionalNodeIndex = <Graph as GraphBase>::OptionalNodeIndex

The optional index type used for nodes.

type OptionalEdgeIndex = <Graph as GraphBase>::OptionalEdgeIndex

The optional index type used for edges.

type NodeIndex = <Graph as GraphBase>::NodeIndex

The index type used for nodes.

type EdgeIndex = <Graph as GraphBase>::EdgeIndex

The index type used for edges.

fn new_none_optional_node_index(&self) -> Self::OptionalNodeIndex

Returns the none value of the optional node index type used by the trait.

fn new_none_optional_edge_index(&self) -> Self::OptionalEdgeIndex

Returns the none value of the optional edge index type used by the trait.

impl<Graph: ImmutableGraphContainer> ImmutableGraphContainer for InducedIncrementalSubgraph<'_, Graph>

type NodeIndices<'a> = FilterNodeIndexIterator<'a, <InducedIncrementalSubgraph<'_, Graph> as GraphBase>::NodeIndex, <InducedIncrementalSubgraph<'_, Graph> as GraphBase>::OptionalNodeIndex, <Graph as ImmutableGraphContainer>::NodeIndices<'a>, InducedIncrementalSubgraph<'_, Graph>> where Self: 'a

An iterator type over the node indices in this graph.

type EdgeIndices<'a> = Filter<<Graph as ImmutableGraphContainer>::EdgeIndices<'a>, Box<dyn Fn(&<Graph as GraphBase>::EdgeIndex) -> bool + 'a, Global>> where Self: 'a

An iterator type over the edge indices in this graph.

fn node_indices(&self) -> Self::NodeIndices<'_>

Returns an iterator over the node indices in this graph.

fn edge_indices(&self) -> Self::EdgeIndices<'_>

Returns an iterator over the edge indices in this graph.

type NodeIndicesCopied = IntoIter<<Graph as GraphBase>::NodeIndex, Global>

An iterator type over the node indices in this graph. The iterator is independent of the lifetime of self, and hence allows concurrent modifications during iteration. Note that any modification to the graph is not reflected in the iterator after construction.

type EdgeIndicesCopied = IntoIter<<Graph as GraphBase>::EdgeIndex, Global>

An iterator type over the edge indices in this graph. The iterator is independent of the lifetime of self, and hence allows concurrent modifications during iteration. Note that any modification to the graph is not reflected in the iterator after construction.

fn node_indices_copied(&self) -> Self::NodeIndicesCopied

Returns an iterator over the node indices in this graph. The iterator is independent of the lifetime of self, and hence allows concurrent modifications during iteration. Note that any modification to the graph is not reflected in the iterator after construction.

fn edge_indices_copied(&self) -> Self::EdgeIndicesCopied

Returns an iterator over the edge indices in this graph. The iterator is independent of the lifetime of self, and hence allows concurrent modifications during iteration. Note that any modification to the graph is not reflected in the iterator after construction.

fn contains_node_index(&self, node_id: Self::NodeIndex) -> bool

Returns true if this graph contains the given node index.

fn contains_edge_index(&self, edge_id: Self::EdgeIndex) -> bool

Returns true if this graph contains the given edge index.

fn node_count(&self) -> usize

Returns the amount of nodes in this graph.

fn edge_count(&self) -> usize

Returns the amount of edges in this graph.

fn node_data(&self, node_id: Self::NodeIndex) -> &Self::NodeData

Returns a reference to the node data associated with the given node id, or None if there is no such node.

fn edge_data(&self, edge_id: Self::EdgeIndex) -> &Self::EdgeData

Returns a reference to the edge data associated with the given edge id, or None if there is no such edge.

fn edge_endpoints(&self, edge_id: Self::EdgeIndex) -> Edge<Self::NodeIndex>

Returns the endpoints of an edge.

fn is_empty(&self) -> bool

Returns true if the graph is empty, i.e. contains no nodes or edges.

fn do_all_edges_endpoints_exist(&self) -> bool

Returns true if the nodes returned by edge_endpoints are part of the graph for all edges.

impl<Graph: SubgraphBase> SubgraphBase for InducedIncrementalSubgraph<'_, Graph>

type RootGraph = <Graph as SubgraphBase>::RootGraph

The root graph of this subgraph, which is either its parent or the root of a DAG of subgraphs.

fn root(&self) -> &Self::RootGraph

Returns a reference to the root graph of this subgraph.