Struct GraphMap

pub struct GraphMap<N, E, Ty, S = RandomState>
where
    S: BuildHasher,
{ /* private fields */ }

GraphMap<N, E, Ty> is a graph datastructure using an associative array of its node weights N.

It uses an combined adjacency list and sparse adjacency matrix representation, using O(|V| + |E|) space, and allows testing for edge existence in constant time.

GraphMap is parameterized over:

• Associated data N for nodes and E for edges, called weights.
• The node weight N must implement Copy and will be used as node identifier, duplicated into several places in the data structure. It must be suitable as a hash table key (implementing Eq + Hash). The node type must also implement Ord so that the implementation can order the pair (a, b) for an edge connecting any two nodes a and b.
• E can be of arbitrary type.
• Edge type Ty that determines whether the graph edges are directed or undirected.

You can use the type aliases UnGraphMap and DiGraphMap for convenience.

GraphMap does not allow parallel edges, but self loops are allowed.

Depends on crate feature graphmap (default).

Implementations

impl<N, E, Ty, S> GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

pub fn new() -> Self

where S: Default,

Create a new GraphMap

pub fn with_capacity(nodes: usize, edges: usize) -> Self

where S: Default,

Create a new GraphMap with estimated capacity.

pub fn with_capacity_and_hasher(nodes: usize, edges: usize, hasher: S) -> Self

where S: Clone,

Create a new GraphMap with estimated capacity, and specified hasher.

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

Return the current node and edge capacity of the graph.

pub fn is_directed(&self) -> bool

Whether the graph has directed edges.

pub fn from_edges<I>(iterable: I) -> Self

where I: IntoIterator, I::Item: IntoWeightedEdge<E, NodeId = N>, S: Default,

Create a new GraphMap from an iterable of edges.

Node values are taken directly from the list. 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::graphmap::UnGraphMap;

// Create a new undirected GraphMap.
// Use a type hint to have `()` be the edge weight type.
let gr = UnGraphMap::<_, ()>::from_edges(&[
    (0, 1), (0, 2), (0, 3),
    (1, 2), (1, 3),
    (2, 3),
]);

pub fn node_count(&self) -> usize

Return the number of nodes in the graph.

pub fn edge_count(&self) -> usize

Return the number of edges in the graph.

pub fn clear(&mut self)

Remove all nodes and edges

pub fn add_node(&mut self, n: N) -> N

Add node n to the graph.

pub fn remove_node(&mut self, n: N) -> bool

Return true if node n was removed.

Computes in O(V) time, due to the removal of edges with other nodes.

pub fn contains_node(&self, n: N) -> bool

Return true if the node is contained in the graph.

pub fn add_edge(&mut self, a: N, b: N, weight: E) -> Option<E>

Add an edge connecting a and b to the graph, with associated data weight. For a directed graph, the edge is directed from a to b.

Inserts nodes a and/or b if they aren’t already part of the graph.

Return None if the edge did not previously exist, otherwise, the associated data is updated and the old value is returned as Some(old_weight).

// Create a GraphMap with directed edges, and add one edge to it
use petgraph::graphmap::DiGraphMap;

let mut g = DiGraphMap::new();
g.add_edge("x", "y", -1);
assert_eq!(g.node_count(), 2);
assert_eq!(g.edge_count(), 1);
assert!(g.contains_edge("x", "y"));
assert!(!g.contains_edge("y", "x"));

pub fn remove_edge(&mut self, a: N, b: N) -> Option<E>

Remove edge from a to b from the graph and return the edge weight.

Return None if the edge didn’t exist.

// Create a GraphMap with undirected edges, and add and remove an edge.
use petgraph::graphmap::UnGraphMap;

let mut g = UnGraphMap::new();
g.add_edge("x", "y", -1);

let edge_data = g.remove_edge("y", "x");
assert_eq!(edge_data, Some(-1));
assert_eq!(g.edge_count(), 0);

pub fn contains_edge(&self, a: N, b: N) -> bool

Return true if the edge connecting a with b is contained in the graph.

pub fn nodes(&self) -> Nodes<'_, N>

Return an iterator over the nodes of the graph.

Iterator element type is N.

pub fn neighbors(&self, a: N) -> Neighbors<'_, N, Ty>

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

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

Produces an empty iterator if the node doesn’t exist.
Iterator element type is N.

pub fn neighbors_directed( &self, a: N, dir: Direction, ) -> NeighborsDirected<'_, N, Ty>

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 from or to a.

Produces an empty iterator if the node doesn’t exist.
Iterator element type is N.

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

Return an iterator of target nodes with an edge starting from a, paired with their respective edge weights.

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

Produces an empty iterator if the node doesn’t exist.
Iterator element type is (N, N, &E).

pub fn edges_directed( &self, a: N, dir: Direction, ) -> EdgesDirected<'_, N, E, Ty, S>

Return an iterator of target nodes with an edge starting from a, paired with their respective edge weights.

• 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 doesn’t exist.
Iterator element type is (N, N, &E).

pub fn edge_weight(&self, a: N, b: N) -> Option<&E>

Return a reference to the edge weight connecting a with b, or None if the edge does not exist in the graph.

pub fn edge_weight_mut(&mut self, a: N, b: N) -> Option<&mut E>

Return a mutable reference to the edge weight connecting a with b, or None if the edge does not exist in the graph.

pub fn all_edges(&self) -> AllEdges<'_, N, E, Ty>

Return an iterator over all edges of the graph with their weight in arbitrary order.

Iterator element type is (N, N, &E)

pub fn all_edges_mut(&mut self) -> AllEdgesMut<'_, N, E, Ty>

Return an iterator over all edges of the graph in arbitrary order, with a mutable reference to their weight.

Iterator element type is (N, N, &mut E)

pub fn into_graph<Ix>(self) -> Graph<N, E, Ty, Ix>

where Ix: IndexType,

Return a Graph that corresponds to this GraphMap.

1. Note that node and edge indices in the Graph have nothing in common with the GraphMaps node weights N. The node weights N are used as node weights in the resulting Graph, too.
2. Note that the index type is user-chosen.

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

Panics if the number of nodes or edges does not fit with the resulting graph’s index type.

pub fn from_graph<Ix>(graph: Graph<N, E, Ty, Ix>) -> Self

where Ix: IndexType, E: Clone, S: Default,

Creates a GraphMap that corresponds to the given Graph.

Warning: Nodes with the same weight are merged and only the last parallel edge is kept. Node and edge indices of the Graph are lost. Only use this function if the node weights are distinct and there are no parallel edges.

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

Trait Implementations

impl<N, E, Ty> Build for GraphMap<N, E, Ty>

where Ty: EdgeType, N: NodeTrait,

fn add_node(&mut self, weight: Self::NodeWeight) -> Self::NodeId

fn add_edge( &mut self, a: Self::NodeId, b: Self::NodeId, weight: Self::EdgeWeight, ) -> Option<Self::EdgeId>

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

fn update_edge( &mut self, a: Self::NodeId, b: Self::NodeId, weight: Self::EdgeWeight, ) -> Self::EdgeId

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

impl<N: Clone, E: Clone, Ty: Clone, S> Clone for GraphMap<N, E, Ty, S>

where S: BuildHasher + Clone,

fn clone(&self) -> GraphMap<N, E, Ty, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N, E, Ty> Create for GraphMap<N, E, Ty>

where Ty: EdgeType, N: NodeTrait,

fn with_capacity(nodes: usize, edges: usize) -> Self

impl<N, E, Ty, S> Data for GraphMap<N, E, Ty, S>

where N: Copy + PartialEq, Ty: EdgeType, S: BuildHasher,

type NodeWeight = N

type EdgeWeight = E

impl<N: Eq + Hash + Debug, E: Debug, Ty: EdgeType, S: BuildHasher> Debug for GraphMap<N, E, Ty, S>

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

Formats the value using the given formatter.

impl<N, E, Ty, S> Default for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher + Default,

Create a new empty GraphMap.

fn default() -> Self

Returns the “default value” for a type.

impl<'de, N, E, Ty, S> Deserialize<'de> for GraphMap<N, E, Ty, S>

where Ty: EdgeType, N: NodeTrait + Deserialize<'de>, E: Clone + Deserialize<'de>, S: BuildHasher + Default,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserializes into a new GraphMap from the same format as the standard Graph. Needs feature serde-1.

Warning: When deseralizing a graph that was not originally a GraphMap, the restrictions from from_graph apply.

Note: The edge weights have to be Clone for this to work.

impl<N, E, Ty, S> EdgeCount for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

fn edge_count(&self) -> usize

Return the number of edges in the graph.

impl<N, E, Ty, S> EdgeIndexable for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

fn edge_bound(&self) -> usize

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

fn to_index(&self, ix: Self::EdgeId) -> usize

Convert a to an integer index.

fn from_index(&self, ix: usize) -> Self::EdgeId

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

impl<N, E, Ty, Item, S> Extend<Item> for GraphMap<N, E, Ty, S>

where Item: IntoWeightedEdge<E, NodeId = N>, N: NodeTrait, Ty: EdgeType, S: BuildHasher,

Extend the graph from an iterable of edges.

Nodes are inserted automatically to match the edges.

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

where I: IntoIterator<Item = Item>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<N, E, Ty> FromElements for GraphMap<N, E, Ty>

where Ty: EdgeType, N: NodeTrait,

fn from_elements<I>(iterable: I) -> Self

where Self: Sized, I: IntoIterator<Item = Element<Self::NodeWeight, Self::EdgeWeight>>,

impl<N, E, Ty, Item, S> FromIterator<Item> for GraphMap<N, E, Ty, S>

where Item: IntoWeightedEdge<E, NodeId = N>, N: NodeTrait, Ty: EdgeType, S: BuildHasher + Default,

Create a new GraphMap from an iterable of edges.

fn from_iter<I>(iterable: I) -> Self

where I: IntoIterator<Item = Item>,

Creates a value from an iterator.

impl<N, E, Ty, S> GetAdjacencyMatrix for GraphMap<N, E, Ty, S>

where N: Copy + Ord + Hash, Ty: EdgeType, S: BuildHasher,

The GraphMap keeps an adjacency matrix internally.

type AdjMatrix = ()

The associated adjacency matrix type

fn adjacency_matrix(&self)

Create the adjacency matrix

fn is_adjacent(&self, _: &(), a: N, b: N) -> bool

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

impl<N, E, Ty, S> GraphBase for GraphMap<N, E, Ty, S>

where N: Copy + PartialEq, S: BuildHasher,

type NodeId = N

node identifier

type EdgeId = (N, N)

edge identifier

impl<N, E, Ty, S> GraphProp for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

type EdgeType = Ty

The kind of edges in the graph.

fn is_directed(&self) -> bool

impl<N, E, Ty, S> Index<(N, N)> for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

Index GraphMap by node pairs to access edge weights.

type Output = E

The returned type after indexing.

fn index(&self, index: (N, N)) -> &E

Performs the indexing (container[index]) operation.

impl<N, E, Ty, S> IndexMut<(N, N)> for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

Index GraphMap by node pairs to access edge weights.

fn index_mut(&mut self, index: (N, N)) -> &mut E

Performs the mutable indexing (container[index]) operation.

impl<'a, N, E: 'a, Ty, S> IntoEdgeReferences for &'a GraphMap<N, E, Ty, S>

where N: NodeTrait + 'a, Ty: EdgeType, S: BuildHasher,

type EdgeRef = (N, N, &'a E)

type EdgeReferences = AllEdges<'a, N, E, Ty>

fn edge_references(self) -> Self::EdgeReferences

impl<'a, N, E: 'a, Ty, S> IntoEdges for &'a GraphMap<N, E, Ty, S>

where N: NodeTrait + 'a, Ty: EdgeType, S: BuildHasher,

type Edges = Edges<'a, N, E, Ty, S>

fn edges(self, a: Self::NodeId) -> Self::Edges

impl<'a, N, E: 'a, Ty, S> IntoEdgesDirected for &'a GraphMap<N, E, Ty, S>

where N: NodeTrait + 'a, Ty: EdgeType, S: BuildHasher,

type EdgesDirected = EdgesDirected<'a, N, E, Ty, S>

fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::EdgesDirected

impl<'a, N, E, Ty, S> IntoNeighbors for &'a GraphMap<N, E, Ty, S>

where N: Copy + Ord + Hash + 'a, Ty: EdgeType, S: BuildHasher,

type Neighbors = Neighbors<'a, N, Ty>

fn neighbors(self, n: Self::NodeId) -> Self::Neighbors

Return an iterator of the neighbors of node a.

impl<'a, N, E, Ty, S> IntoNeighborsDirected for &'a GraphMap<N, E, Ty, S>

where N: Copy + Ord + Hash + 'a, Ty: EdgeType, S: BuildHasher,

type NeighborsDirected = NeighborsDirected<'a, N, Ty>

fn neighbors_directed(self, n: N, dir: Direction) -> Self::NeighborsDirected

impl<'a, N, E: 'a, Ty, S> IntoNodeIdentifiers for &'a GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

type NodeIdentifiers = NodeIdentifiers<'a, N, E, Ty>

fn node_identifiers(self) -> Self::NodeIdentifiers

impl<'a, N, E, Ty, S> IntoNodeReferences for &'a GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

type NodeRef = (N, &'a N)

type NodeReferences = NodeReferences<'a, N, E, Ty>

fn node_references(self) -> Self::NodeReferences

impl<N, E, Ty, S> NodeCount for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

fn node_count(&self) -> usize

impl<N, E, Ty, S> NodeIndexable for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,

fn node_bound(&self) -> usize

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

fn to_index(&self, ix: Self::NodeId) -> usize

Convert a to an integer index.

fn from_index(&self, ix: usize) -> Self::NodeId

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

impl<N, E, Ty, S> Serialize for GraphMap<N, E, Ty, S>

where Ty: EdgeType, N: NodeTrait + Serialize, E: Serialize, S: BuildHasher, Self: Clone,

fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>

where Ser: Serializer,

Serializes the given GraphMap into the same format as the standard Graph. Needs feature serde-1.

Note: the graph has to be Clone for this to work.

impl<N, E, Ty, S> Visitable for GraphMap<N, E, Ty, S>

where N: Copy + Ord + Hash, Ty: EdgeType, S: BuildHasher,

type Map = HashSet<N>

The associated map type

fn visit_map(&self) -> HashSet<N>

Create a new visitor map

fn reset_map(&self, map: &mut Self::Map)

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

impl<N, E, Ty, S> NodeCompactIndexable for GraphMap<N, E, Ty, S>

where N: NodeTrait, Ty: EdgeType, S: BuildHasher,