pub struct StableGraph<N, E, Ty = Directed, Ix = u32> { /* private fields */ }
Expand description

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:

  • Associated data N for nodes and E for edges, also called weights. The associated data can be of arbitrary type.
  • Edge type Ty that determines whether the graph edges are directed or undirected.
  • Index type Ix, which determines the maximum size of the graph.

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.

  • Nodes and edges are each numbered in an interval from 0 to some number m, but not all indices in the range are valid, since gaps are formed by deletions.

  • You can select graph index integer type after the size of the graph. A smaller size may have better performance.

  • Using indices allows mutation while traversing the graph, see Dfs.

  • The StableGraph is a regular rust collection and is Send and Sync (as long as associated data N and E are).

  • Indices don’t allow as much compile time checking as references.

Depends on crate feature stable_graph (default). Stable Graph is still missing a few methods compared to Graph. You can contribute to help it achieve parity.

Implementations§

source§

impl<N, E> StableGraph<N, E>

source

pub fn new() -> StableGraph<N, E>

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.

source§

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

source

pub fn with_capacity(nodes: usize, edges: usize) -> StableGraph<N, E, Ty, Ix>

Create a new StableGraph with estimated capacity.

source

pub fn capacity(&self) -> (usize, usize)

Return the current node and edge capacity of the graph.

source

pub fn reverse(&mut self)

Reverse the direction of all edges

source

pub fn clear(&mut self)

Remove all nodes and edges

source

pub fn clear_edges(&mut self)

Remove all edges

source

pub fn node_count(&self) -> usize

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

Computes in O(1) time.

source

pub fn edge_count(&self) -> usize

Return the number of edges in the graph.

Computes in O(1) time.

source

pub fn is_directed(&self) -> bool

Whether the graph has directed edges or not.

source

pub fn add_node(&mut self, weight: N) -> NodeIndex<Ix>

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 StableGraph is at the maximum number of nodes for its index type.

source

pub fn remove_node(&mut self, a: NodeIndex<Ix>) -> Option<N>

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.

source

pub fn contains_node(&self, a: NodeIndex<Ix>) -> bool

source

pub fn add_edge( &mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E ) -> EdgeIndex<Ix>

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 StableGraph is at the maximum number of edges for its index type.

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

source

pub fn update_edge( &mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E ) -> EdgeIndex<Ix>

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.

source

pub fn remove_edge(&mut self, e: EdgeIndex<Ix>) -> Option<E>

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 connected to the same endpoints as e.

source

pub fn node_weight(&self, a: NodeIndex<Ix>) -> Option<&N>

Access the weight for node a.

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

source

pub fn node_weight_mut(&mut self, a: NodeIndex<Ix>) -> Option<&mut N>

Access the weight for node a, mutably.

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

source

pub fn node_weights(&self) -> impl Iterator<Item = &N>

Return an iterator yielding immutable access to all node weights.

The order in which weights are yielded matches the order of their node indices.

source

pub fn node_weights_mut(&mut self) -> impl Iterator<Item = &mut N>

Return an iterator yielding mutable access to all node weights.

The order in which weights are yielded matches the order of their node indices.

source

pub fn node_indices(&self) -> NodeIndices<'_, N, Ix>

Return an iterator over the node indices of the graph

source

pub fn edge_weight(&self, e: EdgeIndex<Ix>) -> Option<&E>

Access the weight for edge e.

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

source

pub fn edge_weight_mut(&mut self, e: EdgeIndex<Ix>) -> Option<&mut E>

Access the weight for edge e, mutably

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

source

pub fn edge_weights(&self) -> impl Iterator<Item = &E>

Return an iterator yielding immutable access to all edge weights.

The order in which weights are yielded matches the order of their edge indices.

source

pub fn edge_weights_mut(&mut self) -> impl Iterator<Item = &mut E>

Return an iterator yielding mutable access to all edge weights.

The order in which weights are yielded matches the order of their edge indices.

source

pub fn edge_endpoints( &self, e: EdgeIndex<Ix> ) -> Option<(NodeIndex<Ix>, NodeIndex<Ix>)>

Access the source and target nodes for e.

source

pub fn edge_indices(&self) -> EdgeIndices<'_, E, Ix>

Return an iterator over the edge indices of the graph

source

pub fn edges_connecting( &self, a: NodeIndex<Ix>, b: NodeIndex<Ix> ) -> EdgesConnecting<'_, E, Ty, Ix>

Return an iterator over all the edges connecting a and b.

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

Iterator element type is EdgeReference<E, Ix>.

source

pub fn contains_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool

Lookup if there is 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).

source

pub fn find_edge( &self, a: NodeIndex<Ix>, b: NodeIndex<Ix> ) -> Option<EdgeIndex<Ix>>

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).

source

pub fn find_edge_undirected( &self, a: NodeIndex<Ix>, b: NodeIndex<Ix> ) -> Option<(EdgeIndex<Ix>, Direction)>

Lookup an edge between a and b, in either direction.

If the graph is undirected, then this is equivalent to .find_edge().

Return the edge index and its directionality, with Outgoing meaning from a to b and Incoming the reverse, or None if the edge does not exist.

source

pub fn neighbors(&self, a: NodeIndex<Ix>) -> Neighbors<'_, E, Ix>

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.

source

pub fn neighbors_directed( &self, a: NodeIndex<Ix>, dir: Direction ) -> Neighbors<'_, E, Ix>

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.

source

pub fn neighbors_undirected(&self, a: NodeIndex<Ix>) -> Neighbors<'_, E, Ix>

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.

source

pub fn edges(&self, a: NodeIndex<Ix>) -> Edges<'_, E, Ty, Ix>

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>.

source

pub fn edges_directed( &self, a: NodeIndex<Ix>, dir: Direction ) -> Edges<'_, E, Ty, 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, Outgoing: All edges connected to a, with a being the source of each edge.
  • Undirected, Incoming: All edges connected to a, with a being the target of each edge.

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

source

pub fn externals(&self, dir: Direction) -> Externals<'_, N, Ty, Ix>

Return an iterator over either the nodes without edges to them (Incoming) or from them (Outgoing).

An internal node has both incoming and outgoing edges. The nodes in .externals(Incoming) are the source nodes and .externals(Outgoing) are the sinks of the graph.

For a graph with undirected edges, both the sinks and the sources are just the nodes without edges.

The whole iteration computes in O(|V|) time.

source

pub fn index_twice_mut<T, U>( &mut self, i: T, j: U ) -> (&mut <StableGraph<N, E, Ty, Ix> as Index<T>>::Output, &mut <StableGraph<N, E, Ty, Ix> as Index<U>>::Output)
where StableGraph<N, E, Ty, Ix>: IndexMut<T> + IndexMut<U>, T: GraphIndex, U: GraphIndex,

Index the StableGraph 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.

source

pub fn retain_nodes<F>(&mut self, visit: F)
where F: FnMut(Frozen<'_, StableGraph<N, E, Ty, Ix>>, NodeIndex<Ix>) -> bool,

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.

source

pub fn retain_edges<F>(&mut self, visit: F)
where F: FnMut(Frozen<'_, StableGraph<N, E, Ty, Ix>>, EdgeIndex<Ix>) -> bool,

Keep all edges 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 edges are visited is not specified.

The edge indices of the removed edes are invalidated, but none other.

Computes in O(e’‘) time, e’ is the number of affected edges, including the calls to .remove_edge() for each removed edge.

source

pub fn from_edges<I>(iterable: I) -> StableGraph<N, E, Ty, Ix>

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),
]);
source

pub fn map<'a, F, G, N2, E2>( &'a self, node_map: F, edge_map: G ) -> StableGraph<N2, E2, Ty, Ix>
where F: FnMut(NodeIndex<Ix>, &'a N) -> N2, G: FnMut(EdgeIndex<Ix>, &'a E) -> E2,

Create a new StableGraph by mapping node and edge weights to new values.

The resulting graph has the same structure and the same graph indices as self.

source

pub fn filter_map<'a, F, G, N2, E2>( &'a self, node_map: F, edge_map: G ) -> StableGraph<N2, E2, Ty, Ix>
where F: FnMut(NodeIndex<Ix>, &'a N) -> Option<N2>, G: FnMut(EdgeIndex<Ix>, &'a E) -> Option<E2>,

Create a new StableGraph by mapping nodes and edges. A node or edge may be mapped to None to exclude it from the resulting graph.

Nodes are mapped first with the node_map closure, then edge_map is called for the edges that have not had any endpoint removed.

The resulting graph has the structure of a subgraph of the original graph. Nodes and edges that are not removed maintain their old node or edge indices.

source

pub fn extend_with_edges<I>(&mut self, iterable: I)

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§

source§

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

source§

fn add_node( &mut self, weight: <StableGraph<N, E, Ty, Ix> as Data>::NodeWeight ) -> <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId

source§

fn add_edge( &mut self, a: <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId, b: <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId, weight: <StableGraph<N, E, Ty, Ix> as Data>::EdgeWeight ) -> Option<<StableGraph<N, E, Ty, Ix> as GraphBase>::EdgeId>

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

fn update_edge( &mut self, a: <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId, b: <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId, weight: <StableGraph<N, E, Ty, Ix> as Data>::EdgeWeight ) -> <StableGraph<N, E, Ty, Ix> as GraphBase>::EdgeId

Add or update the edge from a to b. Return the id of the affected edge.
source§

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

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

source§

fn clone(&self) -> StableGraph<N, E, Ty, Ix>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, rhs: &StableGraph<N, E, Ty, Ix>)

Performs copy-assignment from source. Read more
source§

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

source§

fn with_capacity(nodes: usize, edges: usize) -> StableGraph<N, E, Ty, Ix>

source§

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

§

type NodeWeight = N

§

type EdgeWeight = E

source§

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

source§

fn node_weight( &self, id: <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId ) -> Option<&<StableGraph<N, E, Ty, Ix> as Data>::NodeWeight>

source§

fn edge_weight( &self, id: <StableGraph<N, E, Ty, Ix> as GraphBase>::EdgeId ) -> Option<&<StableGraph<N, E, Ty, Ix> as Data>::EdgeWeight>

source§

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

source§

fn node_weight_mut( &mut self, id: <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId ) -> Option<&mut <StableGraph<N, E, Ty, Ix> as Data>::NodeWeight>

source§

fn edge_weight_mut( &mut self, id: <StableGraph<N, E, Ty, Ix> as GraphBase>::EdgeId ) -> Option<&mut <StableGraph<N, E, Ty, Ix> as Data>::EdgeWeight>

source§

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

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

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

Create a new empty StableGraph.

source§

fn default() -> StableGraph<N, E, Ty, Ix>

Returns the “default value” for a type. Read more
source§

impl<N, E, Ty, Ix> EdgeCount for StableGraph<N, E, Ty, Ix>
where Ty: EdgeType, Ix: IndexType,

source§

fn edge_count(&self) -> usize

Return the number of edges in the graph.
source§

impl<N, E, Ty, Ix> EdgeIndexable for StableGraph<N, E, Ty, Ix>
where Ty: EdgeType, Ix: IndexType,

source§

fn edge_bound(&self) -> usize

Return an upper bound of the edge indices in the graph (suitable for the size of a bitmap).
source§

fn to_index(&self, ix: EdgeIndex<Ix>) -> usize

Convert a to an integer index.
source§

fn from_index( &self, ix: usize ) -> <StableGraph<N, E, Ty, Ix> as GraphBase>::EdgeId

Convert i to an edge index. i must be a valid value in the graph.
source§

impl<N, E, Ty, Ix> From<Graph<N, E, Ty, Ix>> for StableGraph<N, E, Ty, Ix>
where Ty: EdgeType, Ix: IndexType,

Convert a Graph into a StableGraph

Computes in O(|V| + |E|) time.

The resulting graph has the same node and edge indices as the original graph.

source§

fn from(g: Graph<N, E, Ty, Ix>) -> StableGraph<N, E, Ty, Ix>

Converts to this type from the input type.
source§

impl<N, E, Ty, Ix> From<StableGraph<N, E, Ty, Ix>> for Graph<N, E, Ty, Ix>
where Ty: EdgeType, Ix: IndexType,

Convert a StableGraph into a Graph

Computes in O(|V| + |E|) time.

This translates the stable graph into a graph with node and edge indices in a compact interval without holes (like Graphs always are).

Only if the stable graph had no vacancies after deletions (if node bound was equal to node count, and the same for edges), would the resulting graph have the same node and edge indices as the input.

source§

fn from(graph: StableGraph<N, E, Ty, Ix>) -> Graph<N, E, Ty, Ix>

Converts to this type from the input type.
source§

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

source§

fn from_elements<I>(iterable: I) -> StableGraph<N, E, Ty, Ix>
where StableGraph<N, E, Ty, Ix>: Sized, I: IntoIterator<Item = Element<<StableGraph<N, E, Ty, Ix> as Data>::NodeWeight, <StableGraph<N, E, Ty, Ix> as Data>::EdgeWeight>>,

source§

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

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

§

type AdjMatrix = FixedBitSet

The associated adjacency matrix type
source§

fn adjacency_matrix(&self) -> FixedBitSet

Create the adjacency matrix
source§

fn is_adjacent( &self, matrix: &FixedBitSet, a: NodeIndex<Ix>, b: NodeIndex<Ix> ) -> bool

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

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

§

type NodeId = NodeIndex<Ix>

node identifier
§

type EdgeId = EdgeIndex<Ix>

edge identifier
source§

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

§

type EdgeType = Ty

The kind of edges in the graph.
source§

fn is_directed(&self) -> bool

source§

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

Index the StableGraph by EdgeIndex to access edge weights.

Panics if the edge doesn’t exist.

§

type Output = E

The returned type after indexing.
source§

fn index(&self, index: EdgeIndex<Ix>) -> &E

Performs the indexing (container[index]) operation. Read more
source§

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

Index the StableGraph by NodeIndex to access node weights.

Panics if the node doesn’t exist.

§

type Output = N

The returned type after indexing.
source§

fn index(&self, index: NodeIndex<Ix>) -> &N

Performs the indexing (container[index]) operation. Read more
source§

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

Index the StableGraph by EdgeIndex to access edge weights.

Panics if the edge doesn’t exist.

source§

fn index_mut(&mut self, index: EdgeIndex<Ix>) -> &mut E

Performs the mutable indexing (container[index]) operation. Read more
source§

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

Index the StableGraph by NodeIndex to access node weights.

Panics if the node doesn’t exist.

source§

fn index_mut(&mut self, index: NodeIndex<Ix>) -> &mut N

Performs the mutable indexing (container[index]) operation. Read more
source§

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

source§

fn edge_references( self ) -> <&'a StableGraph<N, E, Ty, Ix> as IntoEdgeReferences>::EdgeReferences

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

Iterator element type is EdgeReference<E, Ix>.

§

type EdgeRef = EdgeReference<'a, E, Ix>

§

type EdgeReferences = EdgeReferences<'a, E, Ix>

source§

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

§

type Edges = Edges<'a, E, Ty, Ix>

source§

fn edges( self, a: <&'a StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId ) -> <&'a StableGraph<N, E, Ty, Ix> as IntoEdges>::Edges

source§

impl<'a, N, E, Ty, Ix> IntoEdgesDirected for &'a StableGraph<N, E, Ty, Ix>
where Ty: EdgeType, Ix: IndexType,

§

type EdgesDirected = Edges<'a, E, Ty, Ix>

source§

fn edges_directed( self, a: <&'a StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId, dir: Direction ) -> <&'a StableGraph<N, E, Ty, Ix> as IntoEdgesDirected>::EdgesDirected

source§

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

§

type Neighbors = Neighbors<'a, E, Ix>

source§

fn neighbors( self, n: <&'a StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId ) -> <&'a StableGraph<N, E, Ty, Ix> as IntoNeighbors>::Neighbors

Return an iterator of the neighbors of node a.
source§

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

source§

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

source§

impl<'a, N, E, Ty, Ix> IntoNodeReferences for &'a StableGraph<N, E, Ty, Ix>
where Ty: EdgeType, Ix: IndexType,

source§

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

source§

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

source§

fn node_bound(&self) -> usize

Return an upper bound of the node indices in the graph

source§

fn to_index(&self, ix: NodeIndex<Ix>) -> usize

Convert a to an integer index.
source§

fn from_index( &self, ix: usize ) -> <StableGraph<N, E, Ty, Ix> as GraphBase>::NodeId

Convert i to a node index. i must be a valid value in the graph.
source§

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

§

type Map = FixedBitSet

The associated map type
source§

fn visit_map(&self) -> FixedBitSet

Create a new visitor map
source§

fn reset_map(&self, map: &mut <StableGraph<N, E, Ty, Ix> as Visitable>::Map)

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

Auto Trait Implementations§

§

impl<N, E, Ty, Ix> RefUnwindSafe for StableGraph<N, E, Ty, Ix>

§

impl<N, E, Ty, Ix> Send for StableGraph<N, E, Ty, Ix>
where E: Send, Ix: Send, N: Send, Ty: Send,

§

impl<N, E, Ty, Ix> Sync for StableGraph<N, E, Ty, Ix>
where E: Sync, Ix: Sync, N: Sync, Ty: Sync,

§

impl<N, E, Ty, Ix> Unpin for StableGraph<N, E, Ty, Ix>
where E: Unpin, Ix: Unpin, N: Unpin, Ty: Unpin,

§

impl<N, E, Ty, Ix> UnwindSafe for StableGraph<N, E, Ty, Ix>
where E: UnwindSafe, Ix: UnwindSafe, N: UnwindSafe, Ty: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

source§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Downcast<T> for T

source§

fn downcast(&self) -> &T

source§

impl<T> Downcast for T
where T: Any,

source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<S> FromSample<S> for S

source§

fn from_sample_(s: S) -> S

source§

impl<T> FromWorld for T
where T: Default,

source§

fn from_world(_world: &mut World) -> T

Creates Self using data from the given World.
source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

source§

fn to_sample_(self) -> U

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

source§

impl<T> Upcast<T> for T

source§

fn upcast(&self) -> Option<&T>

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

source§

impl<T> Settings for T
where T: 'static + Send + Sync,

source§

impl<T> WasmNotSend for T
where T: Send,

source§

impl<T> WasmNotSendSync for T

source§

impl<T> WasmNotSync for T
where T: Sync,