Struct CsrView 

pub struct CsrView<W> { /* private fields */ }

A frozen, read-optimised copy of a graph.

Examples

use xgraph::core::{CsrView, GraphView, ShortestPath};
use xgraph::graph::Graph;

let mut graph = Graph::<u32, &str, &str>::new(false);
let a = graph.add_node("A");
let b = graph.add_node("B");
graph.add_edge(a, b, 5, "rail").unwrap();

let frozen = CsrView::from_view(&graph);
assert_eq!(frozen.node_count(), 2);
// Algorithms are written against the abstraction, so they apply unchanged.
assert_eq!(frozen.dijkstra(a).unwrap()[&b], 5);

Implementations

impl<W: Copy> CsrView<W>

pub fn from_view<G>(source: &G) -> Self

where G: GraphView<Weight = W> + ?Sized,

Builds the projection from any view, in one pass.

The identifiers are the source graph’s own, so a route found here names nodes the original graph still recognises.

Trait Implementations

impl<W: Clone> Clone for CsrView<W>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug> Debug for CsrView<W>

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

Formats the value using the given formatter.

impl<W: Copy> GraphView for CsrView<W>

type Weight = W

The type edge weights are expressed in.

type NodeIds<'a> = CsrNodeIds<'a> where Self: 'a

The iterator node_ids returns.

type Links<'a> = CsrLinks<'a, W> where Self: 'a

The iterator links returns.

fn is_directed(&self) -> bool

Whether edges are one-way.

fn node_count(&self) -> usize

The number of nodes in the graph.

fn edge_count(&self) -> usize

The number of edges in the graph, counting parallel edges separately.

fn contains_node(&self, node: NodeId) -> bool

Whether a node with this ID exists.

fn node_ids(&self) -> Self::NodeIds<'_>

Every node ID in the graph, in ascending order.

fn links(&self, node: NodeId) -> Self::Links<'_>

Every connection leading out of node, one per incident edge.

fn edge_endpoints(&self, edge: EdgeId) -> Option<(NodeId, NodeId)>

The endpoints of an edge, as stored.

fn degree(&self, node: NodeId) -> usize

The number of edges incident to a node, counting parallel edges separately.

fn node_id_vec(&self) -> Vec<NodeId>

Collects the node IDs into a vector.