Struct petgraph::stable_graph::StableGraph [] [src]

pub struct StableGraph<N, E, Ty = Directed, Ix = DefaultIx> { /* fields omitted */ }

StableGraph<N, E, Ty, Ix> is a graph datastructure using an adjacency list representation.

The graph does not invalidate any unrelated node or edge indices when items are removed.

StableGraph is parameterized over:

The graph uses O(|V| + |E|) space, and allows fast node and edge insert and efficient graph search.

It implements O(e') edge lookup and edge and node removals, where e' is some local measure of edge count.

Depends on crate feature stable_graph (default). This is a new feature in petgraph. You can contribute to help it achieve parity with Graph.

Methods

impl<N, E> StableGraph<N, E, Directed>
[src]

Create a new StableGraph with directed edges.

This is a convenience method. See StableGraph::with_capacity or StableGraph::default for a constructor that is generic in all the type parameters of StableGraph.

impl<N, E, Ty, Ix> StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Create a new StableGraph with estimated capacity.

Return the current node and edge capacity of the graph.

Remove all nodes and edges

Return the number of nodes (vertices) in the graph.

Computes in O(1) time.

Return the number of edges in the graph.

Computes in O(1) time.

Whether the graph has directed edges or not.

Add a node (also called vertex) with associated data weight to the graph.

Computes in O(1) time.

Return the index of the new node.

Panics if the Graph is at the maximum number of nodes for its index type.

Remove a from the graph if it exists, and return its weight. If it doesn't exist in the graph, return None.

The node index a is invalidated, but none other. Edge indices are invalidated as they would be following the removal of each edge with an endpoint in a.

Computes in O(e') time, where e' is the number of affected edges, including n calls to .remove_edge() where n is the number of edges with an endpoint in a.

Add an edge from a to b to the graph, with its associated data weight.

Return the index of the new edge.

Computes in O(1) time.

Panics if any of the nodes don't exist.
Panics if the Graph is at the maximum number of edges for its index type.

Note: StableGraph allows adding parallel (“duplicate”) edges.

Add or update an edge from a to b. If the edge already exists, its weight is updated.

Return the index of the affected edge.

Computes in O(e') time, where e' is the number of edges connected to a (and b, if the graph edges are undirected).

Panics if any of the nodes don't exist.

Remove an edge and return its edge weight, or None if it didn't exist.

Invalidates the edge index e but no other.

Computes in O(e') time, where e' is the number of edges conneced to the same endpoints as e.

Access the weight for node a.

Also available with indexing syntax: &graph[a].

Access the weight for node a, mutably.

Also available with indexing syntax: &mut graph[a].

Return an iterator over the node indices of the graph

Access the weight for edge e.

Also available with indexing syntax: &graph[e].

Access the weight for edge e, mutably

Also available with indexing syntax: &mut graph[e].

Access the source and target nodes for e.

Lookup an edge from a to b.

Computes in O(e') time, where e' is the number of edges connected to a (and b, if the graph edges are undirected).

Return an iterator of all nodes with an edge starting from a.

  • Directed: Outgoing edges from a.
  • Undirected: All edges connected to a.

Produces an empty iterator if the node doesn't exist.
Iterator element type is NodeIndex<Ix>.

Use .neighbors(a).detach() to get a neighbor walker that does not borrow from the graph.

Return an iterator of all neighbors that have an edge between them and a, in the specified direction. If the graph's edges are undirected, this is equivalent to .neighbors(a).

  • Directed, Outgoing: All edges from a.
  • Directed, Incoming: All edges to a.
  • Undirected: All edges connected to a.

Produces an empty iterator if the node doesn't exist.
Iterator element type is NodeIndex<Ix>.

Use .neighbors_directed(a, dir).detach() to get a neighbor walker that does not borrow from the graph.

Return an iterator of all neighbors that have an edge between them and a, in either direction. If the graph's edges are undirected, this is equivalent to .neighbors(a).

  • Directed and Undirected: All edges connected to a.

Produces an empty iterator if the node doesn't exist.
Iterator element type is NodeIndex<Ix>.

Use .neighbors_undirected(a).detach() to get a neighbor walker that does not borrow from the graph.

Return an iterator of all edges of a.

  • Directed: Outgoing edges from a.
  • Undirected: All edges connected to a.

Produces an empty iterator if the node doesn't exist.
Iterator element type is EdgeReference<E, Ix>.

Return an iterator of all edges of a, in the specified direction.

  • Directed, Outgoing: All edges from a.
  • Directed, Incoming: All edges to a.
  • Undirected: All edges connected to a.

Produces an empty iterator if the node a doesn't exist.
Iterator element type is EdgeReference<E, Ix>.

Index the Graph by two indices, any combination of node or edge indices is fine.

Panics if the indices are equal or if they are out of bounds.

Keep all nodes that return true from the visit closure, remove the others.

visit is provided a proxy reference to the graph, so that the graph can be walked and associated data modified.

The order nodes are visited is not specified.

The node indices of the removed nodes are invalidated, but none other. Edge indices are invalidated as they would be following the removal of each edge with an endpoint in a removed node.

Computes in O(n + e') time, where n is the number of node indices and e' is the number of affected edges, including n calls to .remove_edge() where n is the number of edges with an endpoint in a removed node.

Create a new StableGraph from an iterable of edges.

Node weights N are set to default values. Edge weights E may either be specified in the list, or they are filled with default values.

Nodes are inserted automatically to match the edges.

use petgraph::stable_graph::StableGraph;

let gr = StableGraph::<(), i32>::from_edges(&[
    (0, 1), (0, 2), (0, 3),
    (1, 2), (1, 3),
    (2, 3),
]);

Extend the graph from an iterable of edges.

Node weights N are set to default values. Edge weights E may either be specified in the list, or they are filled with default values.

Nodes are inserted automatically to match the edges.

Trait Implementations

impl<'a, N, E: 'a, Ty, Ix> IntoNeighbors for &'a StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Return an iterator of the neighbors of node a.

impl<'a, N, E: 'a, Ty, Ix> IntoNeighborsDirected for &'a StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<'a, N, E: 'a, Ty, Ix> IntoNodeIdentifiers for &'a StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> NodeCount for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> GraphProp for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

The kind edges in the graph.

impl<N, E, Ty, Ix> GraphBase for StableGraph<N, E, Ty, Ix> where
    Ix: IndexType
[src]

node identifier

edge identifier

impl<N, E, Ty, Ix> Visitable for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

The associated map type

Create a new visitor map

Reset the visitor map (and resize to new size of graph if needed)

impl<N, E, Ty, Ix> Data for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> DataMap for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> DataMapMut for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> Build for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Add a new edge. If parallel edges (duplicate) are not allowed and the edge already exists, return None. Read more

Add or update the edge from a to b. Return the id of the affected edge. Read more

impl<N, E, Ty, Ix> Create for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> FromElements for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<N, E, Ty, Ix> Debug for StableGraph<N, E, Ty, Ix> where
    N: Debug,
    E: Debug,
    Ty: EdgeType,
    Ix: IndexType
[src]

Formats the value using the given formatter.

impl<N, E, Ty, Ix: IndexType> Clone for StableGraph<N, E, Ty, Ix> where
    N: Clone,
    E: Clone
[src]

The resulting cloned graph has the same graph indices as self.

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

impl<N, E, Ty, Ix> Index<NodeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Index the StableGraph by NodeIndex to access node weights.

Panics if the node doesn't exist.

The returned type after indexing

The method for the indexing (container[index]) operation

impl<N, E, Ty, Ix> IndexMut<NodeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Index the StableGraph by NodeIndex to access node weights.

Panics if the node doesn't exist.

The method for the mutable indexing (container[index]) operation

impl<N, E, Ty, Ix> Index<EdgeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Index the StableGraph by EdgeIndex to access edge weights.

Panics if the edge doesn't exist.

The returned type after indexing

The method for the indexing (container[index]) operation

impl<N, E, Ty, Ix> IndexMut<EdgeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Index the StableGraph by EdgeIndex to access edge weights.

Panics if the edge doesn't exist.

The method for the mutable indexing (container[index]) operation

impl<N, E, Ty, Ix> Default for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Create a new empty StableGraph.

Returns the "default value" for a type. Read more

impl<'a, N, E, Ty, Ix> IntoEdges for &'a StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

impl<'a, N: 'a, E: 'a, Ty, Ix> IntoEdgeReferences for &'a StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Create an iterator over all edges in the graph, in indexed order.

Iterator element type is EdgeReference<E, Ix>.

impl<N, E, Ty, Ix> NodeIndexable for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

Return an upper bound of the node indices in the graph

Convert a to an integer index.

Convert i to a node index

impl<N, E, Ty, Ix> GetAdjacencyMatrix for StableGraph<N, E, Ty, Ix> where
    Ty: EdgeType,
    Ix: IndexType
[src]

The adjacency matrix for Graph is a bitmap that's computed by .adjacency_matrix().

The associated adjacency matrix type

Create the adjacency matrix

Return true if there is an edge from a to b, false otherwise. Read more