Struct Builder 

pub struct Builder<T> { /* private fields */ }

Graph builder.

Implementations

impl<T> Builder<T>

pub fn add_node(&mut self, data: T) -> usize

Adds a node to the graph.

Examples

use zrx_graph::Graph;

// Create graph builder and add nodes
let mut builder = Graph::builder();
let a = builder.add_node("a");
let b = builder.add_node("b");

pub fn add_edge(&mut self, source: usize, target: usize) -> Result

Adds an edge to the graph.

Errors

In case the source or target node doesn’t exist, Error::NotFound is returned, to make sure the graph does not contain stale node references. By returning an error instead of panicking, we can provide recoverable and proper error handling to the caller.

This is mentionable, as some other graph libraries will just panic and crash the program, like the popular petgraph crate. Additionally, note that this method does not check whether an edge already exists, as the existence of multiple edges is a valid use case in some scenarios.

Examples

use zrx_graph::Graph;

// Create graph builder and add nodes
let mut builder = Graph::builder();
let a = builder.add_node("a");
let b = builder.add_node("b");
let c = builder.add_node("c");

// Create edges between nodes
builder.add_edge(a, b)?;
builder.add_edge(b, c)?;

pub fn iter(&self) -> Range<usize>

Creates an iterator over the graph builder.

This iterator emits the node indices, which is exactly the same as iterating over the adjacency list using 0..self.len().

Examples

use zrx_graph::topology::Adjacency;
use zrx_graph::Graph;

// Create graph builder and add nodes
let mut builder = Graph::builder();
let a = builder.add_node("a");
let b = builder.add_node("b");
let c = builder.add_node("c");

// Create edges between nodes
builder.add_edge(a, b)?;
builder.add_edge(b, c)?;

// Create iterator over graph builder
for node in builder.iter() {
    println!("{node:?}");
}

pub fn build(self) -> Graph<T>

Builds the graph.

This method creates the actual graph from the builder, which brings the graph into an executable form to allow for very efficient traversal.

Examples

use zrx_graph::Graph;

// Create graph builder and add nodes
let mut builder = Graph::builder();
let a = builder.add_node("a");
let b = builder.add_node("b");
let c = builder.add_node("c");

// Create edges between nodes
builder.add_edge(a, b)?;
builder.add_edge(b, c)?;

// Create graph from builder
let graph = builder.build();

impl<T> Builder<T>

pub fn nodes(&self) -> &[T]

Returns a reference to the nodes.

pub fn edges(&self) -> &[Edge]

Returns a reference to the edges.

pub fn len(&self) -> usize

Returns the number of nodes.

pub fn is_empty(&self) -> bool

Returns whether there are any nodes.

Trait Implementations

impl<T: Clone> Clone for Builder<T>

fn clone(&self) -> Builder<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Builder<T>

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

Formats the value using the given formatter.

impl<T> Default for Builder<T>

fn default() -> Self

Creates a graph builder.

Examples

use zrx_graph::Builder;

// Create graph builder
let mut builder = Builder::default();

impl<T> From<Builder<T>> for Graph<T>

fn from(builder: Builder<T>) -> Self

Creates a graph from a builder.

Examples

use zrx_graph::Graph;

// Create graph builder and add nodes
let mut builder = Graph::builder();
let a = builder.add_node("a");
let b = builder.add_node("b");
let c = builder.add_node("c");

// Create edges between nodes
builder.add_edge(a, b)?;
builder.add_edge(b, c)?;

// Create graph from builder
let graph = Graph::from(builder);

impl<T> Index<usize> for Builder<T>

fn index(&self, index: usize) -> &Self::Output

Returns a reference to the node at the index.

Panics

Panics if the index is out of bounds.

Examples

use zrx_graph::topology::Adjacency;
use zrx_graph::Graph;

// Create graph builder and add nodes
let mut builder = Graph::builder();
let a = builder.add_node("a");
let b = builder.add_node("b");
let c = builder.add_node("c");

// Create edges between nodes
builder.add_edge(a, b)?;
builder.add_edge(b, c)?;

// Obtain references to nodes
assert_eq!(&builder[a], &"a");
assert_eq!(&builder[b], &"b");
assert_eq!(&builder[c], &"c");

type Output = T

The returned type after indexing.

impl<T> IntoIterator for &Builder<T>

fn into_iter(self) -> Self::IntoIter

Creates an iterator over the graph builder.

This iterator emits the node indices, which is exactly the same as iterating over the adjacency list using 0..self.len().

Examples

use zrx_graph::topology::Adjacency;
use zrx_graph::Graph;

// Create graph builder and add nodes
let mut builder = Graph::builder();
let a = builder.add_node("a");
let b = builder.add_node("b");
let c = builder.add_node("c");

// Create edges between nodes
builder.add_edge(a, b)?;
builder.add_edge(b, c)?;

// Create iterator over graph builder
for node in &builder {
    println!("{node:?}");
}

type Item = usize

The type of the elements being iterated over.

type IntoIter = Range<usize>

Which kind of iterator are we turning this into?