Apply cargo fmt
diff --git a/benches/common/factories.rs b/benches/common/factories.rs
index f20e7bf..8ab8068 100644
--- a/benches/common/factories.rs
+++ b/benches/common/factories.rs
@@ -1,8 +1,8 @@
use std::marker::PhantomData;
+use petgraph::data::Build;
use petgraph::prelude::*;
use petgraph::visit::NodeIndexable;
-use petgraph::data::Build;
use petgraph::EdgeType;
@@ -154,17 +154,15 @@
/// Parse a text adjacency matrix format into a directed graph
fn parse_graph<Ty, G>(s: &str) -> G
- where Ty: EdgeType,
- G: Default + Build<NodeWeight=(), EdgeWeight=()> + NodeIndexable,
+where
+ Ty: EdgeType,
+ G: Default + Build<NodeWeight = (), EdgeWeight = ()> + NodeIndexable,
{
let mut g: G = Default::default();
let s = s.trim();
let lines = s.lines().filter(|l| !l.is_empty());
for (row, line) in lines.enumerate() {
- for (col, word) in line.split(' ')
- .filter(|s| !s.is_empty())
- .enumerate()
- {
+ for (col, word) in line.split(' ').filter(|s| !s.is_empty()).enumerate() {
let has_edge = word.parse::<i32>().unwrap();
assert!(has_edge == 0 || has_edge == 1);
if has_edge == 0 {
@@ -187,8 +185,9 @@
}
impl<Ty, G> GraphFactory<Ty, G>
- where Ty: EdgeType,
- G: Default + Build<NodeWeight=(), EdgeWeight=()> + NodeIndexable,
+where
+ Ty: EdgeType,
+ G: Default + Build<NodeWeight = (), EdgeWeight = ()> + NodeIndexable,
{
fn new() -> Self {
GraphFactory {
diff --git a/benches/iso.rs b/benches/iso.rs
index 008de39..f0875c1 100644
--- a/benches/iso.rs
+++ b/benches/iso.rs
@@ -1,7 +1,7 @@
#![feature(test)]
-extern crate test;
extern crate petgraph;
+extern crate test;
use test::Bencher;
diff --git a/benches/matrix_graph.rs b/benches/matrix_graph.rs
index 6877a89..72f5aae 100644
--- a/benches/matrix_graph.rs
+++ b/benches/matrix_graph.rs
@@ -5,9 +5,9 @@
use test::Bencher;
-use petgraph::{EdgeType, Directed, Outgoing, Incoming};
use petgraph::algo;
-use petgraph::matrix_graph::{MatrixGraph, node_index};
+use petgraph::matrix_graph::{node_index, MatrixGraph};
+use petgraph::{Directed, EdgeType, Incoming, Outgoing};
#[bench]
fn add_100_nodes(b: &mut test::Bencher) {
@@ -41,7 +41,8 @@
let nodes: Vec<_> = (0..100).map(|_| g.add_node(())).collect();
let g = g;
- let edges_to_add: Vec<_> = nodes.iter()
+ let edges_to_add: Vec<_> = nodes
+ .iter()
.enumerate()
.map(|(i, &node)| {
let edges: Vec<_> = (0..5)
@@ -156,10 +157,7 @@
let s = s.trim();
let lines = s.lines().filter(|l| !l.is_empty());
for (row, line) in lines.enumerate() {
- for (col, word) in line.split(' ')
- .filter(|s| !s.is_empty())
- .enumerate()
- {
+ for (col, word) in line.split(' ').filter(|s| !s.is_empty()).enumerate() {
let has_edge = word.parse::<i32>().unwrap();
assert!(has_edge == 0 || has_edge == 1);
if has_edge == 0 {
diff --git a/benches/ograph.rs b/benches/ograph.rs
index 23ac271..d3f2986 100644
--- a/benches/ograph.rs
+++ b/benches/ograph.rs
@@ -13,9 +13,7 @@
let n = og.add_node(x);
og.add_edge(fst, n, ());
}
- b.iter(|| {
- og.add_node(1)
- })
+ b.iter(|| og.add_node(1))
}
#[bench]
@@ -47,7 +45,7 @@
}
//println!("{}", og);
b.iter(|| {
- for _ in 0 .. 100 {
+ for _ in 0..100 {
og.remove_node(fst);
}
})
diff --git a/benches/stable_graph.rs b/benches/stable_graph.rs
index ca4aed8..9dffd91 100644
--- a/benches/stable_graph.rs
+++ b/benches/stable_graph.rs
@@ -3,8 +3,8 @@
extern crate petgraph;
extern crate test;
-use test::Bencher;
use petgraph::prelude::*;
+use test::Bencher;
#[allow(dead_code)]
mod common;
diff --git a/benches/unionfind.rs b/benches/unionfind.rs
index cf7066e..dd4446a 100644
--- a/benches/unionfind.rs
+++ b/benches/unionfind.rs
@@ -1,7 +1,7 @@
#![feature(test)]
-extern crate test;
extern crate petgraph;
+extern crate test;
use test::Bencher;
@@ -16,9 +16,7 @@
let a = ungraph().praust_a();
let b = ungraph().praust_b();
- bench.iter(|| {
- (connected_components(&a), connected_components(&b))
- });
+ bench.iter(|| (connected_components(&a), connected_components(&b)));
}
#[bench]
@@ -26,9 +24,7 @@
let a = digraph().praust_a();
let b = digraph().praust_b();
- bench.iter(|| {
- (connected_components(&a), connected_components(&b))
- });
+ bench.iter(|| (connected_components(&a), connected_components(&b)));
}
#[bench]
@@ -36,9 +32,7 @@
let a = ungraph().full_a();
let b = ungraph().full_b();
- bench.iter(|| {
- (connected_components(&a), connected_components(&b))
- });
+ bench.iter(|| (connected_components(&a), connected_components(&b)));
}
#[bench]
@@ -46,9 +40,7 @@
let a = digraph().full_a();
let b = digraph().full_b();
- bench.iter(|| {
- (connected_components(&a), connected_components(&b))
- });
+ bench.iter(|| (connected_components(&a), connected_components(&b)));
}
#[bench]
@@ -56,9 +48,7 @@
let a = ungraph().petersen_a();
let b = ungraph().petersen_b();
- bench.iter(|| {
- (connected_components(&a), connected_components(&b))
- });
+ bench.iter(|| (connected_components(&a), connected_components(&b)));
}
#[bench]
@@ -66,9 +56,7 @@
let a = digraph().petersen_a();
let b = digraph().petersen_b();
- bench.iter(|| {
- (connected_components(&a), connected_components(&b))
- });
+ bench.iter(|| (connected_components(&a), connected_components(&b)));
}
#[bench]
@@ -76,9 +64,7 @@
let a = ungraph().praust_a();
let b = ungraph().praust_b();
- bench.iter(|| {
- (is_cyclic_undirected(&a), is_cyclic_undirected(&b))
- });
+ bench.iter(|| (is_cyclic_undirected(&a), is_cyclic_undirected(&b)));
}
#[bench]
@@ -86,9 +72,7 @@
let a = digraph().praust_a();
let b = digraph().praust_b();
- bench.iter(|| {
- (is_cyclic_undirected(&a), is_cyclic_undirected(&b))
- });
+ bench.iter(|| (is_cyclic_undirected(&a), is_cyclic_undirected(&b)));
}
#[bench]
@@ -96,9 +80,7 @@
let a = ungraph().full_a();
let b = ungraph().full_b();
- bench.iter(|| {
- (is_cyclic_undirected(&a), is_cyclic_undirected(&b))
- });
+ bench.iter(|| (is_cyclic_undirected(&a), is_cyclic_undirected(&b)));
}
#[bench]
@@ -106,9 +88,7 @@
let a = digraph().full_a();
let b = digraph().full_b();
- bench.iter(|| {
- (is_cyclic_undirected(&a), is_cyclic_undirected(&b))
- });
+ bench.iter(|| (is_cyclic_undirected(&a), is_cyclic_undirected(&b)));
}
#[bench]
@@ -116,9 +96,7 @@
let a = ungraph().petersen_a();
let b = ungraph().petersen_b();
- bench.iter(|| {
- (is_cyclic_undirected(&a), is_cyclic_undirected(&b))
- });
+ bench.iter(|| (is_cyclic_undirected(&a), is_cyclic_undirected(&b)));
}
#[bench]
@@ -126,9 +104,7 @@
let a = digraph().petersen_a();
let b = digraph().petersen_b();
- bench.iter(|| {
- (is_cyclic_undirected(&a), is_cyclic_undirected(&b))
- });
+ bench.iter(|| (is_cyclic_undirected(&a), is_cyclic_undirected(&b)));
}
#[bench]
@@ -136,9 +112,7 @@
let a = ungraph().praust_a();
let b = ungraph().praust_b();
- bench.iter(|| {
- (min_spanning_tree(&a), min_spanning_tree(&b))
- });
+ bench.iter(|| (min_spanning_tree(&a), min_spanning_tree(&b)));
}
#[bench]
@@ -146,9 +120,7 @@
let a = digraph().praust_a();
let b = digraph().praust_b();
- bench.iter(|| {
- (min_spanning_tree(&a), min_spanning_tree(&b))
- });
+ bench.iter(|| (min_spanning_tree(&a), min_spanning_tree(&b)));
}
#[bench]
@@ -156,9 +128,7 @@
let a = ungraph().full_a();
let b = ungraph().full_b();
- bench.iter(|| {
- (min_spanning_tree(&a), min_spanning_tree(&b))
- });
+ bench.iter(|| (min_spanning_tree(&a), min_spanning_tree(&b)));
}
#[bench]
@@ -166,9 +136,7 @@
let a = digraph().full_a();
let b = digraph().full_b();
- bench.iter(|| {
- (min_spanning_tree(&a), min_spanning_tree(&b))
- });
+ bench.iter(|| (min_spanning_tree(&a), min_spanning_tree(&b)));
}
#[bench]
@@ -176,9 +144,7 @@
let a = ungraph().petersen_a();
let b = ungraph().petersen_b();
- bench.iter(|| {
- (min_spanning_tree(&a), min_spanning_tree(&b))
- });
+ bench.iter(|| (min_spanning_tree(&a), min_spanning_tree(&b)));
}
#[bench]
@@ -186,7 +152,5 @@
let a = digraph().petersen_a();
let b = digraph().petersen_b();
- bench.iter(|| {
- (min_spanning_tree(&a), min_spanning_tree(&b))
- });
+ bench.iter(|| (min_spanning_tree(&a), min_spanning_tree(&b)));
}
diff --git a/serialization-tests/src/lib.rs b/serialization-tests/src/lib.rs
index e69de29..8b13789 100644
--- a/serialization-tests/src/lib.rs
+++ b/serialization-tests/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/serialization-tests/tests/serialization.rs b/serialization-tests/tests/serialization.rs
index a82ff88..e4d13c4 100644
--- a/serialization-tests/tests/serialization.rs
+++ b/serialization-tests/tests/serialization.rs
@@ -1,24 +1,25 @@
-
extern crate petgraph;
-#[macro_use] extern crate quickcheck;
+#[macro_use]
+extern crate quickcheck;
+extern crate bincode;
extern crate itertools;
extern crate serde_json;
-extern crate bincode;
-#[macro_use] extern crate defmac;
+#[macro_use]
+extern crate defmac;
use std::collections::HashSet;
use std::fmt::Debug;
use std::iter::FromIterator;
-use itertools::{Itertools, repeat_n};
use itertools::assert_equal;
+use itertools::{repeat_n, Itertools};
+use petgraph::graph::{edge_index, node_index, IndexType};
use petgraph::prelude::*;
-use petgraph::EdgeType;
-use petgraph::graph::{node_index, edge_index, IndexType};
use petgraph::visit::EdgeRef;
-use petgraph::visit::NodeIndexable;
use petgraph::visit::IntoEdgeReferences;
+use petgraph::visit::NodeIndexable;
+use petgraph::EdgeType;
// graphs are the equal, down to graph indices
// this is a strict notion of graph equivalence:
@@ -26,20 +27,27 @@
// * Requires equal node and edge indices, equal weights
// * Does not require: edge for node order
pub fn assert_graph_eq<N, N2, E, Ty, Ix>(g: &Graph<N, E, Ty, Ix>, h: &Graph<N2, E, Ty, Ix>)
- where N: PartialEq<N2> + Debug, N2: PartialEq<N2> + Debug, E: PartialEq + Debug,
- Ty: EdgeType,
- Ix: IndexType,
+where
+ N: PartialEq<N2> + Debug,
+ N2: PartialEq<N2> + Debug,
+ E: PartialEq + Debug,
+ Ty: EdgeType,
+ Ix: IndexType,
{
assert_eq!(g.node_count(), h.node_count());
assert_eq!(g.edge_count(), h.edge_count());
// same node weigths
- assert_equal(g.raw_nodes().iter().map(|n| &n.weight),
- h.raw_nodes().iter().map(|n| &n.weight));
+ assert_equal(
+ g.raw_nodes().iter().map(|n| &n.weight),
+ h.raw_nodes().iter().map(|n| &n.weight),
+ );
// same edge weigths
- assert_equal(g.raw_edges().iter().map(|n| &n.weight),
- h.raw_edges().iter().map(|n| &n.weight));
+ assert_equal(
+ g.raw_edges().iter().map(|n| &n.weight),
+ h.raw_edges().iter().map(|n| &n.weight),
+ );
for e1 in g.edge_references() {
let (a2, b2) = h.edge_endpoints(e1.id()).unwrap();
@@ -63,7 +71,9 @@
// * Requires equal node and edge indices, equal weights
// * Does not require: edge for node order
pub fn assert_stable_graph_eq<N, E>(g: &StableGraph<N, E>, h: &StableGraph<N, E>)
- where N: PartialEq + Debug, E: PartialEq + Debug,
+where
+ N: PartialEq + Debug,
+ E: PartialEq + Debug,
{
assert_eq!(g.node_count(), h.node_count());
assert_eq!(g.edge_count(), h.edge_count());
@@ -71,7 +81,8 @@
// same node weigths
assert_equal(
(0..g.node_bound()).map(|i| g.node_weight(node_index(i))),
- (0..h.node_bound()).map(|i| h.node_weight(node_index(i))));
+ (0..h.node_bound()).map(|i| h.node_weight(node_index(i))),
+ );
let last_edge_g = g.edge_references().next_back();
let last_edge_h = h.edge_references().next_back();
@@ -83,7 +94,8 @@
// same edge weigths
assert_equal(
(0..lgi).map(|i| g.edge_weight(edge_index(i))),
- (0..lhi).map(|i| h.edge_weight(edge_index(i))));
+ (0..lhi).map(|i| h.edge_weight(edge_index(i))),
+ );
}
for e1 in g.edge_references() {
@@ -102,10 +114,10 @@
}
}
-
fn make_graph<Ty, Ix>() -> Graph<&'static str, i32, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
let mut g = Graph::default();
let a = g.add_node("A");
@@ -131,8 +143,9 @@
}
fn make_stable_graph<Ty, Ix>() -> StableGraph<&'static str, i32, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
let mut g = StableGraph::default();
let a = g.add_node("A");
@@ -203,7 +216,6 @@
"edges":[[0,1,7],[2,0,9],[0,3,14],[1,2,10],[3,2,2],[3,4,9],[1,5,15],[2,5,11],[4,5,6]]
}"#;
-
type DiGraphNils = DiGraph<(), ()>;
type UnGraphNils = UnGraph<(), ()>;
type DiGraphNilsU8 = DiGraph<(), (), u8>;
@@ -215,19 +227,19 @@
}
#[test]
-#[should_panic(expected="edge property mismatch")]
+#[should_panic(expected = "edge property mismatch")]
fn from_json_graph_nils_edge_property_mismatch() {
let _: UnGraphNils = fromjson!(DIGRAPH_NILS);
}
#[test]
-#[should_panic(expected="does not exist")]
+#[should_panic(expected = "does not exist")]
fn from_json_graph_nils_index_oob() {
let _: DiGraphNils = fromjson!(DIGRAPH_NILS_INDEX_OOB);
}
#[test]
-#[should_panic(expected="expected u8")]
+#[should_panic(expected = "expected u8")]
fn from_json_graph_nils_index_too_large() {
let _: DiGraphNilsU8 = fromjson!(DIGRAPH_NILS_INDEX_OUTSIDE_U8);
}
@@ -238,21 +250,31 @@
}
#[test]
-#[should_panic(expected="expected unit")]
+#[should_panic(expected = "expected unit")]
fn from_json_graph_from_edge_type_1() {
let _: DiGraphNils = fromjson!(DIGRAPH_STRI32);
}
#[test]
-#[should_panic(expected="expected a string")]
+#[should_panic(expected = "expected a string")]
fn from_json_graph_from_edge_type_2() {
let _: DiGraphStrI32 = fromjson!(DIGRAPH_NILS);
}
#[test]
fn from_json_digraph_str_i32() {
- let g4nodes = ["A","B","C","D","E","F"];
- let g4edges = [[0,1,7],[2,0,9],[0,3,14],[1,2,10],[3,2,2],[3,4,9],[1,5,15],[2,5,11],[4,5,6]];
+ let g4nodes = ["A", "B", "C", "D", "E", "F"];
+ let g4edges = [
+ [0, 1, 7],
+ [2, 0, 9],
+ [0, 3, 14],
+ [1, 2, 10],
+ [3, 2, 2],
+ [3, 4, 9],
+ [1, 5, 15],
+ [2, 5, 11],
+ [4, 5, 6],
+ ];
type GSI = DiGraph<String, i32>;
type GSISmall = DiGraph<String, i32, u8>;
@@ -280,17 +302,19 @@
// ensure we fail if node or edge count exceeds index max
use serde_json::from_str;
- let j1_big = &format!("{}{}{}",
- r#"
+ let j1_big = &format!(
+ "{}{}{}",
+ r#"
{"nodes": [
"#,
- repeat_n(0, 300).format(", "),
- r#"
+ repeat_n(0, 300).format(", "),
+ r#"
],
"edge_property": "directed",
"edges": []
}
- "#);
+ "#
+ );
type G8 = DiGraph<i32, (), u8>;
type G16 = DiGraph<i32, (), u16>;
@@ -313,13 +337,15 @@
// ensure we fail if node or edge count exceeds index max
use serde_json::from_str;
- let j1_big = format!("{}{}{}",
- r#"
+ let j1_big = format!(
+ "{}{}{}",
+ r#"
{"nodes": [0],
"edge_property": "directed",
"edges": ["#,
- repeat_n("[0, 0, 1]", (1 << 16) - 1).format(", "),
- "]}");
+ repeat_n("[0, 0, 1]", (1 << 16) - 1).format(", "),
+ "]}"
+ );
type G8 = DiGraph<i32, i32, u8>;
type G16 = DiGraph<i32, i32, u16>;
@@ -350,7 +376,6 @@
assert_stable_graph_eq(&g1, &g2);
}
-
// bincode macros
defmac!(encode ref g => bincode::serialize(g).unwrap());
defmac!(decode ref data => bincode::deserialize(data).unwrap());
diff --git a/src/algo/dominators.rs b/src/algo/dominators.rs
index 4d39f2e..85c2b63 100644
--- a/src/algo/dominators.rs
+++ b/src/algo/dominators.rs
@@ -21,14 +21,16 @@
/// The dominance relation for some graph and root.
#[derive(Debug, Clone)]
pub struct Dominators<N>
- where N: Copy + Eq + Hash
+where
+ N: Copy + Eq + Hash,
{
root: N,
dominators: HashMap<N, N>,
}
impl<N> Dominators<N>
- where N: Copy + Eq + Hash
+where
+ N: Copy + Eq + Hash,
{
/// Get the root node used to construct these dominance relations.
pub fn root(&self) -> N {
@@ -81,14 +83,16 @@
/// Iterator for a node's dominators.
pub struct DominatorsIter<'a, N>
- where N: 'a + Copy + Eq + Hash
+where
+ N: 'a + Copy + Eq + Hash,
{
dominators: &'a Dominators<N>,
node: Option<N>,
}
impl<'a, N> Iterator for DominatorsIter<'a, N>
- where N: 'a + Copy + Eq + Hash
+where
+ N: 'a + Copy + Eq + Hash,
{
type Item = N;
@@ -115,8 +119,9 @@
///
/// [0]: http://www.cs.rice.edu/~keith/EMBED/dom.pdf
pub fn simple_fast<G>(graph: G, root: G::NodeId) -> Dominators<G::NodeId>
- where G: IntoNeighbors + Visitable,
- <G as GraphBase>::NodeId: Eq + Hash
+where
+ G: IntoNeighbors + Visitable,
+ <G as GraphBase>::NodeId: Eq + Hash,
{
let (post_order, predecessor_sets) = simple_fast_post_order(graph, root);
let length = post_order.len();
@@ -129,7 +134,8 @@
// convert our data structures to play along first.
// Maps a node to its index into `post_order`.
- let node_to_post_order_idx: HashMap<_, _> = post_order.iter()
+ let node_to_post_order_idx: HashMap<_, _> = post_order
+ .iter()
.enumerate()
.map(|(idx, &node)| (node, idx))
.collect();
@@ -156,12 +162,14 @@
// node.
let new_idom_idx = {
- let mut predecessors =
- idx_to_predecessor_vec[idx].iter().filter(|&&p| dominators[p] != UNDEFINED);
- let new_idom_idx = predecessors.next()
- .expect("Because the root is initialized to dominate itself, and is the \
+ let mut predecessors = idx_to_predecessor_vec[idx]
+ .iter()
+ .filter(|&&p| dominators[p] != UNDEFINED);
+ let new_idom_idx = predecessors.next().expect(
+ "Because the root is initialized to dominate itself, and is the \
first node in every path, there must exist a predecessor to this \
- node that also has a dominator");
+ node that also has a dominator",
+ );
predecessors.fold(*new_idom_idx, |new_idom_idx, &predecessor_idx| {
intersect(&dominators, new_idom_idx, predecessor_idx)
})
@@ -182,7 +190,8 @@
Dominators {
root,
- dominators: dominators.into_iter()
+ dominators: dominators
+ .into_iter()
.enumerate()
.map(|(idx, dom_idx)| (post_order[idx], post_order[dom_idx]))
.collect(),
@@ -199,17 +208,22 @@
}
}
-fn predecessor_sets_to_idx_vecs<N>(post_order: &[N],
- node_to_post_order_idx: &HashMap<N, usize>,
- mut predecessor_sets: HashMap<N, HashSet<N>>)
- -> Vec<Vec<usize>>
- where N: Copy + Eq + Hash
+fn predecessor_sets_to_idx_vecs<N>(
+ post_order: &[N],
+ node_to_post_order_idx: &HashMap<N, usize>,
+ mut predecessor_sets: HashMap<N, HashSet<N>>,
+) -> Vec<Vec<usize>>
+where
+ N: Copy + Eq + Hash,
{
- post_order.iter()
+ post_order
+ .iter()
.map(|node| {
- predecessor_sets.remove(node)
+ predecessor_sets
+ .remove(node)
.map(|predecessors| {
- predecessors.into_iter()
+ predecessors
+ .into_iter()
.map(|p| *node_to_post_order_idx.get(&p).unwrap())
.collect()
})
@@ -218,11 +232,13 @@
.collect()
}
-fn simple_fast_post_order<G>(graph: G,
- root: G::NodeId)
- -> (Vec<G::NodeId>, HashMap<G::NodeId, HashSet<G::NodeId>>)
- where G: IntoNeighbors + Visitable,
- <G as GraphBase>::NodeId: Eq + Hash
+fn simple_fast_post_order<G>(
+ graph: G,
+ root: G::NodeId,
+) -> (Vec<G::NodeId>, HashMap<G::NodeId, HashSet<G::NodeId>>)
+where
+ G: IntoNeighbors + Visitable,
+ <G as GraphBase>::NodeId: Eq + Hash,
{
let mut post_order = vec![];
let mut predecessor_sets = HashMap::new();
@@ -231,7 +247,8 @@
post_order.push(node);
for successor in graph.neighbors(node) {
- predecessor_sets.entry(successor)
+ predecessor_sets
+ .entry(successor)
.or_insert_with(HashSet::new)
.insert(node);
}
@@ -248,10 +265,7 @@
fn test_iter_dominators() {
let doms: Dominators<u32> = Dominators {
root: 0,
- dominators: [(2, 1), (1, 0), (0, 0)]
- .iter()
- .cloned()
- .collect(),
+ dominators: [(2, 1), (1, 0), (0, 0)].iter().cloned().collect(),
};
let all_doms: Vec<_> = doms.dominators(2).unwrap().collect();
@@ -262,6 +276,9 @@
let strict_doms: Vec<_> = doms.strict_dominators(2).unwrap().collect();
assert_eq!(vec![1, 0], strict_doms);
- assert_eq!(None::<()>, doms.strict_dominators(99).map(|_| unreachable!()));
+ assert_eq!(
+ None::<()>,
+ doms.strict_dominators(99).map(|_| unreachable!())
+ );
}
}
diff --git a/src/algo/mod.rs b/src/algo/mod.rs
index 6163a2b..aa54405 100644
--- a/src/algo/mod.rs
+++ b/src/algo/mod.rs
@@ -6,46 +6,27 @@
pub mod dominators;
-use std::collections::{BinaryHeap, HashMap};
use std::cmp::min;
+use std::collections::{BinaryHeap, HashMap};
use crate::prelude::*;
-use super::{
- EdgeType,
-};
-use crate::scored::MinScored;
-use super::visit::{
- GraphRef,
- GraphBase,
- Visitable,
- VisitMap,
- IntoNeighbors,
- IntoNeighborsDirected,
- IntoNodeIdentifiers,
- NodeCount,
- NodeIndexable,
- NodeCompactIndexable,
- IntoEdgeReferences,
- IntoEdges,
- Reversed,
-};
+use super::graph::IndexType;
use super::unionfind::UnionFind;
-use super::graph::{
- IndexType,
+use super::visit::{
+ GraphBase, GraphRef, IntoEdgeReferences, IntoEdges, IntoNeighbors, IntoNeighborsDirected,
+ IntoNodeIdentifiers, NodeCompactIndexable, NodeCount, NodeIndexable, Reversed, VisitMap,
+ Visitable,
};
-use crate::visit::{Data, NodeRef, IntoNodeReferences};
+use super::EdgeType;
+use crate::data::Element;
+use crate::scored::MinScored;
use crate::visit::Walker;
-use crate::data::{
- Element,
-};
+use crate::visit::{Data, IntoNodeReferences, NodeRef};
-pub use super::isomorphism::{
- is_isomorphic,
- is_isomorphic_matching,
-};
-pub use super::dijkstra::dijkstra;
pub use super::astar::astar;
+pub use super::dijkstra::dijkstra;
+pub use super::isomorphism::{is_isomorphic, is_isomorphic_matching};
pub use super::simple_paths::all_simple_paths;
/// \[Generic\] Return the number of connected components of the graph.
@@ -87,7 +68,8 @@
/// assert_eq!(connected_components(&graph),1);
/// ```
pub fn connected_components<G>(g: G) -> usize
- where G: NodeCompactIndexable + IntoEdgeReferences,
+where
+ G: NodeCompactIndexable + IntoEdgeReferences,
{
let mut vertex_sets = UnionFind::new(g.node_bound());
for edge in g.edge_references() {
@@ -102,12 +84,12 @@
labels.len()
}
-
/// \[Generic\] Return `true` if the input graph contains a cycle.
///
/// Always treats the input graph as if undirected.
pub fn is_cyclic_undirected<G>(g: G) -> bool
- where G: NodeIndexable + IntoEdgeReferences
+where
+ G: NodeIndexable + IntoEdgeReferences,
{
let mut edge_sets = UnionFind::new(g.node_bound());
for edge in g.edge_references() {
@@ -116,13 +98,12 @@
// union the two vertices of the edge
// -- if they were already the same, then we have a cycle
if !edge_sets.union(g.to_index(a), g.to_index(b)) {
- return true
+ return true;
}
}
false
}
-
/// \[Generic\] Perform a topological sort of a directed graph.
///
/// If the graph was acyclic, return a vector of nodes in topological order:
@@ -134,9 +115,12 @@
///
/// If `space` is not `None`, it is used instead of creating a new workspace for
/// graph traversal. The implementation is iterative.
-pub fn toposort<G>(g: G, space: Option<&mut DfsSpace<G::NodeId, G::Map>>)
- -> Result<Vec<G::NodeId>, Cycle<G::NodeId>>
- where G: IntoNeighborsDirected + IntoNodeIdentifiers + Visitable,
+pub fn toposort<G>(
+ g: G,
+ space: Option<&mut DfsSpace<G::NodeId, G::Map>>,
+) -> Result<Vec<G::NodeId>, Cycle<G::NodeId>>
+where
+ G: IntoNeighborsDirected + IntoNodeIdentifiers + Visitable,
{
// based on kosaraju scc
with_dfs(g, space, |dfs| {
@@ -193,16 +177,16 @@
/// This implementation is recursive; use `toposort` if an alternative is
/// needed.
pub fn is_cyclic_directed<G>(g: G) -> bool
- where G: IntoNodeIdentifiers + IntoNeighbors + Visitable,
+where
+ G: IntoNodeIdentifiers + IntoNeighbors + Visitable,
{
use crate::visit::{depth_first_search, DfsEvent};
- depth_first_search(g, g.node_identifiers(), |event| {
- match event {
- DfsEvent::BackEdge(_, _) => Err(()),
- _ => Ok(()),
- }
- }).is_err()
+ depth_first_search(g, g.node_identifiers(), |event| match event {
+ DfsEvent::BackEdge(_, _) => Err(()),
+ _ => Ok(()),
+ })
+ .is_err()
}
type DfsSpaceType<G> = DfsSpace<<G as GraphBase>::NodeId, <G as Visitable>::Map>;
@@ -214,38 +198,42 @@
}
impl<N, VM> DfsSpace<N, VM>
- where N: Copy + PartialEq,
- VM: VisitMap<N>,
+where
+ N: Copy + PartialEq,
+ VM: VisitMap<N>,
{
pub fn new<G>(g: G) -> Self
- where G: GraphRef + Visitable<NodeId=N, Map=VM>,
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
- DfsSpace {
- dfs: Dfs::empty(g)
- }
+ DfsSpace { dfs: Dfs::empty(g) }
}
}
impl<N, VM> Default for DfsSpace<N, VM>
- where VM: VisitMap<N> + Default,
+where
+ VM: VisitMap<N> + Default,
{
fn default() -> Self {
DfsSpace {
dfs: Dfs {
stack: <_>::default(),
discovered: <_>::default(),
- }
+ },
}
}
}
/// Create a Dfs if it's needed
fn with_dfs<G, F, R>(g: G, space: Option<&mut DfsSpaceType<G>>, f: F) -> R
- where G: GraphRef + Visitable,
- F: FnOnce(&mut Dfs<G::NodeId, G::Map>) -> R
+where
+ G: GraphRef + Visitable,
+ F: FnOnce(&mut Dfs<G::NodeId, G::Map>) -> R,
{
let mut local_visitor;
- let dfs = if let Some(v) = space { &mut v.dfs } else {
+ let dfs = if let Some(v) = space {
+ &mut v.dfs
+ } else {
local_visitor = Dfs::empty(g);
&mut local_visitor
};
@@ -258,10 +246,14 @@
///
/// If `space` is not `None`, it is used instead of creating a new workspace for
/// graph traversal.
-pub fn has_path_connecting<G>(g: G, from: G::NodeId, to: G::NodeId,
- space: Option<&mut DfsSpace<G::NodeId, G::Map>>)
- -> bool
- where G: IntoNeighbors + Visitable,
+pub fn has_path_connecting<G>(
+ g: G,
+ from: G::NodeId,
+ to: G::NodeId,
+ space: Option<&mut DfsSpace<G::NodeId, G::Map>>,
+) -> bool
+where
+ G: IntoNeighbors + Visitable,
{
with_dfs(g, space, |dfs| {
dfs.reset(g);
@@ -273,7 +265,8 @@
/// Renamed to `kosaraju_scc`.
#[deprecated(note = "renamed to kosaraju_scc")]
pub fn scc<G>(g: G) -> Vec<Vec<G::NodeId>>
- where G: IntoNeighborsDirected + Visitable + IntoNodeIdentifiers,
+where
+ G: IntoNeighborsDirected + Visitable + IntoNodeIdentifiers,
{
kosaraju_scc(g)
}
@@ -290,7 +283,8 @@
///
/// This implementation is iterative and does two passes over the nodes.
pub fn kosaraju_scc<G>(g: G) -> Vec<Vec<G::NodeId>>
- where G: IntoNeighborsDirected + Visitable + IntoNodeIdentifiers,
+where
+ G: IntoNeighborsDirected + Visitable + IntoNodeIdentifiers,
{
let mut dfs = DfsPostOrder::empty(g);
@@ -299,7 +293,7 @@
let mut finish_order = Vec::with_capacity(0);
for i in g.node_identifiers() {
if dfs.discovered.is_visited(&i) {
- continue
+ continue;
}
dfs.move_to(i);
@@ -341,10 +335,10 @@
///
/// This implementation is recursive and does one pass over the nodes.
pub fn tarjan_scc<G>(g: G) -> Vec<Vec<G::NodeId>>
- where G: IntoNodeIdentifiers + IntoNeighbors + NodeIndexable
+where
+ G: IntoNodeIdentifiers + IntoNeighbors + NodeIndexable,
{
- #[derive(Copy, Clone)]
- #[derive(Debug)]
+ #[derive(Copy, Clone, Debug)]
struct NodeData {
index: Option<usize>,
lowlink: usize,
@@ -353,8 +347,9 @@
#[derive(Debug)]
struct Data<'a, G>
- where G: NodeIndexable,
- G::NodeId: 'a
+ where
+ G: NodeIndexable,
+ G::NodeId: 'a,
{
index: usize,
nodes: Vec<NodeData>,
@@ -363,10 +358,13 @@
}
fn scc_visit<G>(v: G::NodeId, g: G, data: &mut Data<G>)
- where G: IntoNeighbors + NodeIndexable
+ where
+ G: IntoNeighbors + NodeIndexable,
{
macro_rules! node {
- ($node:expr) => (data.nodes[g.to_index($node)])
+ ($node:expr) => {
+ data.nodes[g.to_index($node)]
+ };
}
if node![v].index.is_some() {
@@ -405,7 +403,9 @@
let w = data.stack.pop().unwrap();
node![w].on_stack = false;
cur_scc.push(w);
- if g.to_index(w) == g.to_index(v) { break; }
+ if g.to_index(w) == g.to_index(v) {
+ break;
+ }
}
data.sccs.push(cur_scc);
}
@@ -414,7 +414,14 @@
let mut sccs = Vec::new();
{
- let map = vec![NodeData { index: None, lowlink: !0, on_stack: false }; g.node_bound()];
+ let map = vec![
+ NodeData {
+ index: None,
+ lowlink: !0,
+ on_stack: false
+ };
+ g.node_bound()
+ ];
let mut data = Data {
index: 0,
@@ -510,9 +517,13 @@
/// assert_eq!(acyclic_condensed_graph.edge_count(), 1);
/// assert_eq!(acyclic_condensed_graph.neighbors(B).collect::<Vec<_>>(), vec![A]);
/// ```
-pub fn condensation<N, E, Ty, Ix>(g: Graph<N, E, Ty, Ix>, make_acyclic: bool) -> Graph<Vec<N>, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+pub fn condensation<N, E, Ty, Ix>(
+ g: Graph<N, E, Ty, Ix>,
+ make_acyclic: bool,
+) -> Graph<Vec<N>, E, Ty, Ix>
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
let sccs = kosaraju_scc(&g);
let mut condensed: Graph<Vec<N>, E, Ty, Ix> = Graph::with_capacity(sccs.len(), g.edge_count());
@@ -558,11 +569,11 @@
///
/// Use `from_elements` to create a graph from the resulting iterator.
pub fn min_spanning_tree<G>(g: G) -> MinSpanningTree<G>
- where G::NodeWeight: Clone,
- G::EdgeWeight: Clone + PartialOrd,
- G: IntoNodeReferences + IntoEdgeReferences + NodeIndexable,
+where
+ G::NodeWeight: Clone,
+ G::EdgeWeight: Clone + PartialOrd,
+ G: IntoNodeReferences + IntoEdgeReferences + NodeIndexable,
{
-
// Initially each vertex is its own disjoint subgraph, track the connectedness
// of the pre-MST with a union & find datastructure.
let subgraphs = UnionFind::new(g.node_bound());
@@ -570,7 +581,10 @@
let edges = g.edge_references();
let mut sort_edges = BinaryHeap::with_capacity(edges.size_hint().0);
for edge in edges {
- sort_edges.push(MinScored(edge.weight().clone(), (edge.source(), edge.target())));
+ sort_edges.push(MinScored(
+ edge.weight().clone(),
+ (edge.source(), edge.target()),
+ ));
}
MinSpanningTree {
@@ -581,12 +595,12 @@
node_map: HashMap::new(),
node_count: 0,
}
-
}
/// An iterator producing a minimum spanning forest of a graph.
pub struct MinSpanningTree<G>
- where G: Data + IntoNodeReferences,
+where
+ G: Data + IntoNodeReferences,
{
graph: G,
node_ids: Option<G::NodeReferences>,
@@ -596,11 +610,11 @@
node_count: usize,
}
-
impl<G> Iterator for MinSpanningTree<G>
- where G: IntoNodeReferences + NodeIndexable,
- G::NodeWeight: Clone,
- G::EdgeWeight: PartialOrd,
+where
+ G: IntoNodeReferences + NodeIndexable,
+ G::NodeWeight: Clone,
+ G::EdgeWeight: PartialOrd,
{
type Item = Element<G::NodeWeight, G::EdgeWeight>;
@@ -610,7 +624,9 @@
if let Some(node) = iter.next() {
self.node_map.insert(g.to_index(node.id()), self.node_count);
self.node_count += 1;
- return Some(Element::Node { weight: node.weight().clone() });
+ return Some(Element::Node {
+ weight: node.weight().clone(),
+ });
}
}
self.node_ids = None;
@@ -628,11 +644,11 @@
// check if the edge would connect two disjoint parts
let (a_index, b_index) = (g.to_index(a), g.to_index(b));
if self.subgraphs.union(a_index, b_index) {
- let (&a_order, &b_order) = match (self.node_map.get(&a_index),
- self.node_map.get(&b_index)) {
- (Some(a_id), Some(b_id)) => (a_id, b_id),
- _ => panic!("Edge references unknown node"),
- };
+ let (&a_order, &b_order) =
+ match (self.node_map.get(&a_index), self.node_map.get(&b_index)) {
+ (Some(a_id), Some(b_id)) => (a_id, b_id),
+ _ => panic!("Edge references unknown node"),
+ };
return Some(Element::Edge {
source: a_order,
target: b_order,
@@ -651,7 +667,8 @@
impl<N> Cycle<N> {
/// Return a node id that participates in the cycle
pub fn node_id(&self) -> N
- where N: Copy
+ where
+ N: Copy,
{
self.0
}
@@ -725,10 +742,13 @@
///
/// assert!(bellman_ford(&graph_with_neg_cycle, NodeIndex::new(0)).is_err());
/// ```
-pub fn bellman_ford<G>(g: G, source: G::NodeId)
- -> Result<(Vec<G::EdgeWeight>, Vec<Option<G::NodeId>>), NegativeCycle>
- where G: NodeCount + IntoNodeIdentifiers + IntoEdges + NodeIndexable,
- G::EdgeWeight: FloatMeasure,
+pub fn bellman_ford<G>(
+ g: G,
+ source: G::NodeId,
+) -> Result<(Vec<G::EdgeWeight>, Vec<Option<G::NodeId>>), NegativeCycle>
+where
+ G: NodeCount + IntoNodeIdentifiers + IntoEdges + NodeIndexable,
+ G::EdgeWeight: FloatMeasure,
{
let mut predecessor = vec![None; g.node_bound()];
let mut distance = vec![<_>::infinite(); g.node_bound()];
@@ -771,29 +791,34 @@
Ok((distance, predecessor))
}
-use std::ops::Add;
use std::fmt::Debug;
+use std::ops::Add;
/// Associated data that can be used for measures (such as length).
-pub trait Measure : Debug + PartialOrd + Add<Self, Output=Self> + Default + Clone {
-}
+pub trait Measure: Debug + PartialOrd + Add<Self, Output = Self> + Default + Clone {}
-impl<M> Measure for M
- where M: Debug + PartialOrd + Add<M, Output=M> + Default + Clone,
-{ }
+impl<M> Measure for M where M: Debug + PartialOrd + Add<M, Output = M> + Default + Clone {}
/// A floating-point measure.
-pub trait FloatMeasure : Measure + Copy {
+pub trait FloatMeasure: Measure + Copy {
fn zero() -> Self;
fn infinite() -> Self;
}
impl FloatMeasure for f32 {
- fn zero() -> Self { 0. }
- fn infinite() -> Self { 1./0. }
+ fn zero() -> Self {
+ 0.
+ }
+ fn infinite() -> Self {
+ 1. / 0.
+ }
}
impl FloatMeasure for f64 {
- fn zero() -> Self { 0. }
- fn infinite() -> Self { 1./0. }
+ fn zero() -> Self {
+ 0.
+ }
+ fn infinite() -> Self {
+ 1. / 0.
+ }
}
diff --git a/src/astar.rs b/src/astar.rs
index b9435f5..56b3e2e 100644
--- a/src/astar.rs
+++ b/src/astar.rs
@@ -1,22 +1,10 @@
-use std::collections::{
- HashMap,
- BinaryHeap,
-};
-use std::collections::hash_map::Entry::{
- Occupied,
- Vacant,
-};
+use std::collections::hash_map::Entry::{Occupied, Vacant};
+use std::collections::{BinaryHeap, HashMap};
use std::hash::Hash;
+use super::visit::{EdgeRef, GraphBase, IntoEdges, VisitMap, Visitable};
use crate::scored::MinScored;
-use super::visit::{
- EdgeRef,
- GraphBase,
- IntoEdges,
- VisitMap,
- Visitable,
-};
use crate::algo::Measure;
@@ -75,15 +63,20 @@
///
/// Returns the total cost + the path of subsequent `NodeId` from start to finish, if one was
/// found.
-pub fn astar<G, F, H, K, IsGoal>(graph: G, start: G::NodeId, mut is_goal: IsGoal,
- mut edge_cost: F, mut estimate_cost: H)
- -> Option<(K, Vec<G::NodeId>)>
- where G: IntoEdges + Visitable,
- IsGoal: FnMut(G::NodeId) -> bool,
- G::NodeId: Eq + Hash,
- F: FnMut(G::EdgeRef) -> K,
- H: FnMut(G::NodeId) -> K,
- K: Measure + Copy,
+pub fn astar<G, F, H, K, IsGoal>(
+ graph: G,
+ start: G::NodeId,
+ mut is_goal: IsGoal,
+ mut edge_cost: F,
+ mut estimate_cost: H,
+) -> Option<(K, Vec<G::NodeId>)>
+where
+ G: IntoEdges + Visitable,
+ IsGoal: FnMut(G::NodeId) -> bool,
+ G::NodeId: Eq + Hash,
+ F: FnMut(G::EdgeRef) -> K,
+ H: FnMut(G::NodeId) -> K,
+ K: Measure + Copy,
{
let mut visited = graph.visit_map();
let mut visit_next = BinaryHeap::new();
@@ -104,7 +97,7 @@
// Don't visit the same node several times, as the first time it was visited it was using
// the shortest available path.
if !visited.visit(node) {
- continue
+ continue;
}
// This lookup can be unwrapped without fear of panic since the node was necessarily scored
@@ -114,7 +107,7 @@
for edge in graph.edges(node) {
let next = edge.target();
if visited.is_visited(&next) {
- continue
+ continue;
}
let mut next_score = node_score + edge_cost(edge);
@@ -128,7 +121,7 @@
} else {
next_score = old_score;
}
- },
+ }
Vacant(ent) => {
ent.insert(next_score);
path_tracker.set_predecessor(next, node);
@@ -144,15 +137,17 @@
}
struct PathTracker<G>
- where G: GraphBase,
- G::NodeId: Eq + Hash,
+where
+ G: GraphBase,
+ G::NodeId: Eq + Hash,
{
came_from: HashMap<G::NodeId, G::NodeId>,
}
impl<G> PathTracker<G>
- where G: GraphBase,
- G::NodeId: Eq + Hash,
+where
+ G: GraphBase,
+ G::NodeId: Eq + Hash,
{
fn new() -> PathTracker<G> {
PathTracker {
diff --git a/src/csr.rs b/src/csr.rs
index a8ffcb0..8a75e3f 100644
--- a/src/csr.rs
+++ b/src/csr.rs
@@ -1,25 +1,21 @@
//! Compressed Sparse Row (CSR) is a sparse adjacency matrix graph.
-use std::marker::PhantomData;
use std::cmp::max;
-use std::ops::{Range, Index, IndexMut};
use std::iter::{Enumerate, Zip};
+use std::marker::PhantomData;
+use std::ops::{Index, IndexMut, Range};
use std::slice::Windows;
-use crate::visit::{EdgeRef, GraphBase, IntoNeighbors, NodeIndexable, IntoEdges};
-use crate::visit::{NodeCompactIndexable, IntoNodeIdentifiers, Visitable};
-use crate::visit::{Data, IntoEdgeReferences, NodeCount, GraphProp};
+use crate::visit::{Data, GraphProp, IntoEdgeReferences, NodeCount};
+use crate::visit::{EdgeRef, GraphBase, IntoEdges, IntoNeighbors, NodeIndexable};
+use crate::visit::{IntoNodeIdentifiers, NodeCompactIndexable, Visitable};
use crate::util::zip;
#[doc(no_inline)]
-pub use crate::graph::{IndexType, DefaultIx};
+pub use crate::graph::{DefaultIx, IndexType};
-use crate::{
- EdgeType,
- Directed,
- IntoWeightedEdge,
-};
+use crate::{Directed, EdgeType, IntoWeightedEdge};
/// Csr node index type, a plain integer.
pub type NodeIndex<Ix = DefaultIx> = Ix;
@@ -60,8 +56,9 @@
}
impl<N, E, Ty, Ix> Default for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn default() -> Self {
Self::new()
@@ -82,8 +79,9 @@
}
impl<N, E, Ty, Ix> Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
/// Create an empty `Csr`.
pub fn new() -> Self {
@@ -115,7 +113,8 @@
/// assert_eq!(graph[4],0);
/// ```
pub fn with_nodes(n: usize) -> Self
- where N: Default,
+ where
+ N: Default,
{
Csr {
column: Vec::new(),
@@ -135,9 +134,9 @@
}
impl<N, E, Ix> Csr<N, E, Directed, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
-
/// Create a new `Csr` from a sorted sequence of edges
///
/// Edges **must** be sorted and unique, where the sort order is the default
@@ -157,13 +156,17 @@
/// ]);
/// ```
pub fn from_sorted_edges<Edge>(edges: &[Edge]) -> Result<Self, EdgesNotSorted>
- where Edge: Clone + IntoWeightedEdge<E, NodeId=NodeIndex<Ix>>,
- N: Default,
+ where
+ Edge: Clone + IntoWeightedEdge<E, NodeId = NodeIndex<Ix>>,
+ N: Default,
{
- let max_node_id = match edges.iter().map(|edge|
- match edge.clone().into_weighted_edge() {
- (x, y, _) => max(x.index(), y.index())
- }).max() {
+ let max_node_id = match edges
+ .iter()
+ .map(|edge| match edge.clone().into_weighted_edge() {
+ (x, y, _) => max(x.index(), y.index()),
+ })
+ .max()
+ {
None => return Ok(Self::with_nodes(0)),
Some(x) => x,
};
@@ -229,10 +232,10 @@
}
impl<N, E, Ty, Ix> Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
-
pub fn node_count(&self) -> usize {
self.row.len() - 1
}
@@ -276,7 +279,8 @@
///
/// **Panics** if `a` or `b` are out of bounds.
pub fn add_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E) -> bool
- where E: Clone,
+ where
+ E: Clone,
{
let ret = self.add_edge_(a, b, weight.clone());
if ret && !self.is_directed() {
@@ -336,7 +340,11 @@
fn neighbors_range(&self, a: NodeIndex<Ix>) -> Range<usize> {
let index = self.row[a.index()];
- let end = self.row.get(a.index() + 1).cloned().unwrap_or_else(|| self.column.len());
+ let end = self
+ .row
+ .get(a.index() + 1)
+ .cloned()
+ .unwrap_or_else(|| self.column.len());
index..end
}
@@ -408,35 +416,48 @@
}
}
-impl<'a, E, Ty, Ix: Copy> Copy for EdgeReference<'a, E, Ty, Ix> { }
+impl<'a, E, Ty, Ix: Copy> Copy for EdgeReference<'a, E, Ty, Ix> {}
impl<'a, Ty, E, Ix> EdgeReference<'a, E, Ty, Ix>
- where Ty: EdgeType,
+where
+ Ty: EdgeType,
{
/// Access the edge’s weight.
///
/// **NOTE** that this method offers a longer lifetime
/// than the trait (unfortunately they don't match yet).
- pub fn weight(&self) -> &'a E { self.weight }
+ pub fn weight(&self) -> &'a E {
+ self.weight
+ }
}
impl<'a, E, Ty, Ix> EdgeRef for EdgeReference<'a, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeId = NodeIndex<Ix>;
type EdgeId = EdgeIndex;
type Weight = E;
- fn source(&self) -> Self::NodeId { self.source }
- fn target(&self) -> Self::NodeId { self.target }
- fn weight(&self) -> &E { self.weight }
- fn id(&self) -> Self::EdgeId { self.index }
+ fn source(&self) -> Self::NodeId {
+ self.source
+ }
+ fn target(&self) -> Self::NodeId {
+ self.target
+ }
+ fn weight(&self) -> &E {
+ self.weight
+ }
+ fn id(&self) -> Self::EdgeId {
+ self.index
+ }
}
impl<'a, E, Ty, Ix> Iterator for Edges<'a, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Item = EdgeReference<'a, E, Ty, Ix>;
fn next(&mut self) -> Option<Self::Item> {
@@ -455,16 +476,18 @@
}
impl<N, E, Ty, Ix> Data for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeWeight = N;
type EdgeWeight = E;
}
impl<'a, N, E, Ty, Ix> IntoEdgeReferences for &'a Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgeRef = EdgeReference<'a, E, Ty, Ix>;
type EdgeReferences = EdgeReferences<'a, E, Ty, Ix>;
@@ -492,8 +515,9 @@
}
impl<'a, E, Ty, Ix> Iterator for EdgeReferences<'a, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Item = EdgeReference<'a, E, Ty, Ix>;
fn next(&mut self) -> Option<Self::Item> {
@@ -507,7 +531,7 @@
target: j,
weight: w,
ty: PhantomData,
- })
+ });
}
if let Some((i, w)) = self.edge_ranges.next() {
let a = w[0];
@@ -522,8 +546,9 @@
}
impl<'a, N, E, Ty, Ix> IntoEdges for &'a Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Edges = Edges<'a, E, Ty, Ix>;
fn edges(self, a: Self::NodeId) -> Self::Edges {
@@ -532,8 +557,9 @@
}
impl<N, E, Ty, Ix> GraphBase for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeId = NodeIndex<Ix>;
type EdgeId = EdgeIndex; // index into edges vector
@@ -542,8 +568,9 @@
use fixedbitset::FixedBitSet;
impl<N, E, Ty, Ix> Visitable for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Map = FixedBitSet;
fn visit_map(&self) -> FixedBitSet {
@@ -563,7 +590,8 @@
}
impl<'a, Ix> Iterator for Neighbors<'a, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
type Item = NodeIndex<Ix>;
@@ -577,8 +605,9 @@
}
impl<'a, N, E, Ty, Ix> IntoNeighbors for &'a Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Neighbors = Neighbors<'a, Ix>;
@@ -597,23 +626,32 @@
}
impl<N, E, Ty, Ix> NodeIndexable for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
- fn node_bound(&self) -> usize { self.node_count() }
- fn to_index(&self, a: Self::NodeId) -> usize { a.index() }
- fn from_index(&self, ix: usize) -> Self::NodeId { Ix::new(ix) }
+ fn node_bound(&self) -> usize {
+ self.node_count()
+ }
+ fn to_index(&self, a: Self::NodeId) -> usize {
+ a.index()
+ }
+ fn from_index(&self, ix: usize) -> Self::NodeId {
+ Ix::new(ix)
+ }
}
impl<N, E, Ty, Ix> NodeCompactIndexable for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
}
impl<N, E, Ty, Ix> Index<NodeIndex<Ix>> for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Output = N;
@@ -623,8 +661,9 @@
}
impl<N, E, Ty, Ix> IndexMut<NodeIndex<Ix>> for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn index_mut(&mut self, ix: NodeIndex<Ix>) -> &mut N {
&mut self.node_weights[ix.index()]
@@ -637,7 +676,8 @@
}
impl<Ix> Iterator for NodeIdentifiers<Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
type Item = NodeIndex<Ix>;
@@ -651,8 +691,9 @@
}
impl<'a, N, E, Ty, Ix> IntoNodeIdentifiers for &'a Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeIdentifiers = NodeIdentifiers<Ix>;
fn node_identifiers(self) -> Self::NodeIdentifiers {
@@ -664,8 +705,9 @@
}
impl<N, E, Ty, Ix> NodeCount for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn node_count(&self) -> usize {
(*self).node_count()
@@ -673,8 +715,9 @@
}
impl<N, E, Ty, Ix> GraphProp for Csr<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgeType = Ty;
}
@@ -696,11 +739,11 @@
#[cfg(test)]
mod tests {
use super::Csr;
- use crate::Undirected;
+ use crate::algo::bellman_ford;
+ use crate::algo::tarjan_scc;
use crate::visit::Dfs;
use crate::visit::VisitMap;
- use crate::algo::tarjan_scc;
- use crate::algo::bellman_ford;
+ use crate::Undirected;
#[test]
fn csr1() {
@@ -727,11 +770,11 @@
#[test]
fn csr_undirected() {
- /*
- [ 1 . 1
- . . 1
- 1 1 1 ]
- */
+ /*
+ [ 1 . 1
+ . . 1
+ 1 1 1 ]
+ */
let mut m: Csr<(), (), Undirected> = Csr::with_nodes(3);
m.add_edge(0, 0, ());
@@ -749,11 +792,7 @@
#[test]
fn csr_from_error_1() {
// not sorted in source
- let m: Csr = Csr::from_sorted_edges(&[
- (0, 1),
- (1, 0),
- (0, 2),
- ]).unwrap();
+ let m: Csr = Csr::from_sorted_edges(&[(0, 1), (1, 0), (0, 2)]).unwrap();
println!("{:?}", m);
}
@@ -761,25 +800,14 @@
#[test]
fn csr_from_error_2() {
// not sorted in target
- let m: Csr = Csr::from_sorted_edges(&[
- (0, 1),
- (1, 0),
- (1, 2),
- (1, 1),
- ]).unwrap();
+ let m: Csr = Csr::from_sorted_edges(&[(0, 1), (1, 0), (1, 2), (1, 1)]).unwrap();
println!("{:?}", m);
}
#[test]
fn csr_from() {
- let m: Csr = Csr::from_sorted_edges(&[
- (0, 1),
- (0, 2),
- (1, 0),
- (1, 1),
- (2, 2),
- (2, 4),
- ]).unwrap();
+ let m: Csr =
+ Csr::from_sorted_edges(&[(0, 1), (0, 2), (1, 0), (1, 1), (2, 2), (2, 4)]).unwrap();
println!("{:?}", m);
assert_eq!(m.neighbors_slice(0), &[1, 2]);
assert_eq!(m.neighbors_slice(1), &[0, 1]);
@@ -797,15 +825,14 @@
(1, 1),
(1, 3),
(2, 2),
-
// disconnected subgraph
(4, 4),
(4, 5),
- ]).unwrap();
+ ])
+ .unwrap();
println!("{:?}", m);
let mut dfs = Dfs::new(&m, 0);
- while let Some(_) = dfs.next(&m) {
- }
+ while let Some(_) = dfs.next(&m) {}
for i in 0..m.node_count() - 2 {
assert!(dfs.discovered.is_visited(&i), "visited {}", i)
}
@@ -817,8 +844,7 @@
dfs.reset(&m);
dfs.move_to(0);
- while let Some(_) = dfs.next(&m) {
- }
+ while let Some(_) = dfs.next(&m) {}
for i in 0..m.node_count() {
assert!(dfs.discovered[i], "visited {}", i)
@@ -838,7 +864,8 @@
(4, 4),
(4, 5),
(5, 2),
- ]).unwrap();
+ ])
+ .unwrap();
println!("{:?}", m);
println!("{:?}", tarjan_scc(&m));
}
@@ -853,12 +880,12 @@
(1, 2, 1.),
(1, 3, 1.),
(2, 3, 3.),
-
(4, 5, 1.),
(5, 7, 2.),
(6, 7, 1.),
(7, 8, 3.),
- ]).unwrap();
+ ])
+ .unwrap();
println!("{:?}", m);
let result = bellman_ford(&m, 0).unwrap();
println!("{:?}", result);
@@ -877,7 +904,8 @@
(1, 2, 1.),
(1, 3, 1.),
(2, 3, 3.),
- ]).unwrap();
+ ])
+ .unwrap();
let result = bellman_ford(&m, 0);
assert!(result.is_err());
}
@@ -894,12 +922,12 @@
(1, 2, 1.),
(1, 3, 1.),
(2, 3, 3.),
-
(4, 5, 1.),
(5, 7, 2.),
(6, 7, 1.),
(7, 8, 3.),
- ]).unwrap();
+ ])
+ .unwrap();
let mut copy = Vec::new();
for e in m.edge_references() {
copy.push((e.source(), e.target(), *e.weight()));
diff --git a/src/data.rs b/src/data.rs
index bfe528d..7bb5411 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -1,23 +1,15 @@
//! Graph traits for associated data and graph construction.
-
-use crate::Graph;
-#[cfg(feature = "stable_graph")]
-use crate::stable_graph::StableGraph;
-use crate::{
- EdgeType,
-};
use crate::graph::IndexType;
#[cfg(feature = "graphmap")]
use crate::graphmap::{GraphMap, NodeTrait};
-use crate::visit::{
- Data,
- NodeCount,
- NodeIndexable,
- Reversed,
-};
+#[cfg(feature = "stable_graph")]
+use crate::stable_graph::StableGraph;
+use crate::visit::{Data, NodeCount, NodeIndexable, Reversed};
+use crate::EdgeType;
+use crate::Graph;
-trait_template!{
+trait_template! {
/// Access node and edge weights (associated data).
pub trait DataMap : Data {
@section self
@@ -27,12 +19,14 @@
}
macro_rules! access0 {
- ($e:expr) => ($e.0);
+ ($e:expr) => {
+ $e.0
+ };
}
-DataMap!{delegate_impl []}
-DataMap!{delegate_impl [['a, G], G, &'a mut G, deref_twice]}
-DataMap!{delegate_impl [[G], G, Reversed<G>, access0]}
+DataMap! {delegate_impl []}
+DataMap! {delegate_impl [['a, G], G, &'a mut G, deref_twice]}
+DataMap! {delegate_impl [[G], G, Reversed<G>, access0]}
trait_template! {
/// Access node and edge weights mutably.
@@ -43,43 +37,49 @@
}
}
-DataMapMut!{delegate_impl [['a, G], G, &'a mut G, deref_twice]}
-DataMapMut!{delegate_impl [[G], G, Reversed<G>, access0]}
+DataMapMut! {delegate_impl [['a, G], G, &'a mut G, deref_twice]}
+DataMapMut! {delegate_impl [[G], G, Reversed<G>, access0]}
/// A graph that can be extended with further nodes and edges
-pub trait Build : Data + NodeCount {
+pub trait Build: Data + NodeCount {
fn add_node(&mut self, weight: Self::NodeWeight) -> Self::NodeId;
/// Add a new edge. If parallel edges (duplicate) are not allowed and
/// the edge already exists, return `None`.
- fn add_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Option<Self::EdgeId> {
+ fn add_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Option<Self::EdgeId> {
Some(self.update_edge(a, b, weight))
}
/// Add or update the edge from `a` to `b`. Return the id of the affected
/// edge.
- fn update_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Self::EdgeId;
+ fn update_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Self::EdgeId;
}
/// A graph that can be created
-pub trait Create : Build + Default {
+pub trait Create: Build + Default {
fn with_capacity(nodes: usize, edges: usize) -> Self;
}
impl<N, E, Ty, Ix> Data for Graph<N, E, Ty, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
type NodeWeight = N;
type EdgeWeight = E;
}
impl<N, E, Ty, Ix> DataMap for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn node_weight(&self, id: Self::NodeId) -> Option<&Self::NodeWeight> {
self.node_weight(id)
@@ -90,8 +90,9 @@
}
impl<N, E, Ty, Ix> DataMapMut for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn node_weight_mut(&mut self, id: Self::NodeId) -> Option<&mut Self::NodeWeight> {
self.node_weight_mut(id)
@@ -103,8 +104,9 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> DataMap for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn node_weight(&self, id: Self::NodeId) -> Option<&Self::NodeWeight> {
self.node_weight(id)
@@ -116,8 +118,9 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> DataMapMut for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn node_weight_mut(&mut self, id: Self::NodeId) -> Option<&mut Self::NodeWeight> {
self.node_weight_mut(id)
@@ -128,65 +131,73 @@
}
impl<N, E, Ty, Ix> Build for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn add_node(&mut self, weight: Self::NodeWeight) -> Self::NodeId {
self.add_node(weight)
}
- fn add_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Option<Self::EdgeId>
- {
+ fn add_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Option<Self::EdgeId> {
Some(self.add_edge(a, b, weight))
}
- fn update_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Self::EdgeId
- {
+ fn update_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Self::EdgeId {
self.update_edge(a, b, weight)
}
}
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> Build for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn add_node(&mut self, weight: Self::NodeWeight) -> Self::NodeId {
self.add_node(weight)
}
- fn add_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Option<Self::EdgeId>
- {
+ fn add_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Option<Self::EdgeId> {
Some(self.add_edge(a, b, weight))
}
- fn update_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Self::EdgeId
- {
+ fn update_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Self::EdgeId {
self.update_edge(a, b, weight)
}
}
#[cfg(feature = "graphmap")]
impl<N, E, Ty> Build for GraphMap<N, E, Ty>
- where Ty: EdgeType,
- N: NodeTrait,
+where
+ Ty: EdgeType,
+ N: NodeTrait,
{
fn add_node(&mut self, weight: Self::NodeWeight) -> Self::NodeId {
self.add_node(weight)
}
- fn add_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Option<Self::EdgeId>
- {
+ fn add_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Option<Self::EdgeId> {
if self.contains_edge(a, b) {
None
} else {
@@ -195,20 +206,21 @@
Some((a, b))
}
}
- fn update_edge(&mut self,
- a: Self::NodeId,
- b: Self::NodeId,
- weight: Self::EdgeWeight) -> Self::EdgeId
- {
+ fn update_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Self::EdgeId {
self.add_edge(a, b, weight);
(a, b)
}
}
-
impl<N, E, Ty, Ix> Create for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn with_capacity(nodes: usize, edges: usize) -> Self {
Self::with_capacity(nodes, edges)
@@ -217,8 +229,9 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> Create for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn with_capacity(nodes: usize, edges: usize) -> Self {
Self::with_capacity(nodes, edges)
@@ -227,8 +240,9 @@
#[cfg(feature = "graphmap")]
impl<N, E, Ty> Create for GraphMap<N, E, Ty>
- where Ty: EdgeType,
- N: NodeTrait,
+where
+ Ty: EdgeType,
+ N: NodeTrait,
{
fn with_capacity(nodes: usize, edges: usize) -> Self {
Self::with_capacity(nodes, edges)
@@ -243,22 +257,21 @@
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Element<N, E> {
/// A graph node.
- Node {
- weight: N,
- },
+ Node { weight: N },
/// A graph edge.
Edge {
source: usize,
target: usize,
weight: E,
- }
+ },
}
/// Create a graph from an iterator of elements.
-pub trait FromElements : Create {
+pub trait FromElements: Create {
fn from_elements<I>(iterable: I) -> Self
- where Self: Sized,
- I: IntoIterator<Item=Element<Self::NodeWeight, Self::EdgeWeight>>,
+ where
+ Self: Sized,
+ I: IntoIterator<Item = Element<Self::NodeWeight, Self::EdgeWeight>>,
{
let mut gr = Self::with_capacity(0, 0);
// usize -> NodeId map
@@ -268,19 +281,23 @@
Element::Node { weight } => {
map.push(gr.add_node(weight));
}
- Element::Edge { source, target, weight } => {
+ Element::Edge {
+ source,
+ target,
+ weight,
+ } => {
gr.add_edge(map[source], map[target], weight);
}
}
}
gr
}
-
}
fn from_elements_indexable<G, I>(iterable: I) -> G
- where G: Create + NodeIndexable,
- I: IntoIterator<Item=Element<G::NodeWeight, G::EdgeWeight>>,
+where
+ G: Create + NodeIndexable,
+ I: IntoIterator<Item = Element<G::NodeWeight, G::EdgeWeight>>,
{
let mut gr = G::with_capacity(0, 0);
let map = |gr: &G, i| gr.from_index(i);
@@ -289,7 +306,11 @@
Element::Node { weight } => {
gr.add_node(weight);
}
- Element::Edge { source, target, weight } => {
+ Element::Edge {
+ source,
+ target,
+ weight,
+ } => {
let from = map(&gr, source);
let to = map(&gr, target);
gr.add_edge(from, to, weight);
@@ -300,12 +321,14 @@
}
impl<N, E, Ty, Ix> FromElements for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn from_elements<I>(iterable: I) -> Self
- where Self: Sized,
- I: IntoIterator<Item=Element<Self::NodeWeight, Self::EdgeWeight>>,
+ where
+ Self: Sized,
+ I: IntoIterator<Item = Element<Self::NodeWeight, Self::EdgeWeight>>,
{
from_elements_indexable(iterable)
}
@@ -313,12 +336,14 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> FromElements for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn from_elements<I>(iterable: I) -> Self
- where Self: Sized,
- I: IntoIterator<Item=Element<Self::NodeWeight, Self::EdgeWeight>>,
+ where
+ Self: Sized,
+ I: IntoIterator<Item = Element<Self::NodeWeight, Self::EdgeWeight>>,
{
from_elements_indexable(iterable)
}
@@ -326,19 +351,21 @@
#[cfg(feature = "graphmap")]
impl<N, E, Ty> FromElements for GraphMap<N, E, Ty>
- where Ty: EdgeType,
- N: NodeTrait,
+where
+ Ty: EdgeType,
+ N: NodeTrait,
{
fn from_elements<I>(iterable: I) -> Self
- where Self: Sized,
- I: IntoIterator<Item=Element<Self::NodeWeight, Self::EdgeWeight>>,
+ where
+ Self: Sized,
+ I: IntoIterator<Item = Element<Self::NodeWeight, Self::EdgeWeight>>,
{
from_elements_indexable(iterable)
}
}
/// Iterator adaptors for iterators of `Element`.
-pub trait ElementIterator<N, E> : Iterator<Item=Element<N, E>> {
+pub trait ElementIterator<N, E>: Iterator<Item = Element<N, E>> {
/// Create an iterator adaptor that filters graph elements.
///
/// The function `f` is called with each element and if its return value
@@ -349,8 +376,9 @@
/// This filter adapts the edge source and target indices in the
/// stream so that they are correct after the removals.
fn filter_elements<F>(self, f: F) -> FilterElements<Self, F>
- where Self: Sized,
- F: FnMut(Element<&mut N, &mut E>) -> bool,
+ where
+ Self: Sized,
+ F: FnMut(Element<&mut N, &mut E>) -> bool,
{
FilterElements {
iter: self,
@@ -361,8 +389,7 @@
}
}
-impl<N, E, I: ?Sized> ElementIterator<N, E> for I
- where I: Iterator<Item=Element<N, E>> { }
+impl<N, E, I: ?Sized> ElementIterator<N, E> for I where I: Iterator<Item = Element<N, E>> {}
/// An iterator that filters graph elements.
///
@@ -377,8 +404,9 @@
}
impl<I, F, N, E> Iterator for FilterElements<I, F>
- where I: Iterator<Item=Element<N, E>>,
- F: FnMut(Element<&mut N, &mut E>) -> bool,
+where
+ I: Iterator<Item = Element<N, E>>,
+ F: FnMut(Element<&mut N, &mut E>) -> bool,
{
type Item = Element<N, E>;
@@ -390,10 +418,21 @@
};
let keep = (self.f)(match elt {
Element::Node { ref mut weight } => Element::Node { weight },
- Element::Edge { source, target, ref mut weight }
- => Element::Edge { source, target, weight },
+ Element::Edge {
+ source,
+ target,
+ ref mut weight,
+ } => Element::Edge {
+ source,
+ target,
+ weight,
+ },
});
- let is_node = if let Element::Node { .. } = elt { true } else { false };
+ let is_node = if let Element::Node { .. } = elt {
+ true
+ } else {
+ false
+ };
if !keep && is_node {
self.map.push(self.node_index);
}
@@ -427,7 +466,7 @@
Err(i) => *target -= i,
}
}
- Element::Node { .. } => { }
+ Element::Node { .. } => {}
}
return Some(elt);
}
diff --git a/src/dijkstra.rs b/src/dijkstra.rs
index b856e60..77852b9 100644
--- a/src/dijkstra.rs
+++ b/src/dijkstra.rs
@@ -1,22 +1,11 @@
-use std::collections::{
- HashMap,
- BinaryHeap,
-};
-use std::collections::hash_map::Entry::{
- Occupied,
- Vacant,
-};
+use std::collections::hash_map::Entry::{Occupied, Vacant};
+use std::collections::{BinaryHeap, HashMap};
use std::hash::Hash;
-use crate::scored::MinScored;
-use super::visit::{
- Visitable,
- VisitMap,
- IntoEdges,
- EdgeRef,
-};
+use super::visit::{EdgeRef, IntoEdges, VisitMap, Visitable};
use crate::algo::Measure;
+use crate::scored::MinScored;
/// \[Generic\] Dijkstra's shortest path algorithm.
///
@@ -80,13 +69,17 @@
/// assert_eq!(res, expected_res);
/// // z is not inside res because there is not path from b to z.
/// ```
-pub fn dijkstra<G, F, K>(graph: G, start: G::NodeId, goal: Option<G::NodeId>,
- mut edge_cost: F)
- -> HashMap<G::NodeId, K>
- where G: IntoEdges + Visitable,
- G::NodeId: Eq + Hash,
- F: FnMut(G::EdgeRef) -> K,
- K: Measure + Copy,
+pub fn dijkstra<G, F, K>(
+ graph: G,
+ start: G::NodeId,
+ goal: Option<G::NodeId>,
+ mut edge_cost: F,
+) -> HashMap<G::NodeId, K>
+where
+ G: IntoEdges + Visitable,
+ G::NodeId: Eq + Hash,
+ F: FnMut(G::EdgeRef) -> K,
+ K: Measure + Copy,
{
let mut visited = graph.visit_map();
let mut scores = HashMap::new();
@@ -97,24 +90,26 @@
visit_next.push(MinScored(zero_score, start));
while let Some(MinScored(node_score, node)) = visit_next.pop() {
if visited.is_visited(&node) {
- continue
+ continue;
}
if goal.as_ref() == Some(&node) {
- break
+ break;
}
for edge in graph.edges(node) {
let next = edge.target();
if visited.is_visited(&next) {
- continue
+ continue;
}
let mut next_score = node_score + edge_cost(edge);
match scores.entry(next) {
- Occupied(ent) => if next_score < *ent.get() {
- *ent.into_mut() = next_score;
+ Occupied(ent) => {
+ if next_score < *ent.get() {
+ *ent.into_mut() = next_score;
//predecessor.insert(next.clone(), node.clone());
- } else {
- next_score = *ent.get();
- },
+ } else {
+ next_score = *ent.get();
+ }
+ }
Vacant(ent) => {
ent.insert(next_score);
//predecessor.insert(next.clone(), node.clone());
diff --git a/src/dot.rs b/src/dot.rs
index 3ee079e..b9f44dc 100644
--- a/src/dot.rs
+++ b/src/dot.rs
@@ -2,7 +2,7 @@
use std::fmt::{self, Display, Write};
-use crate::visit::{GraphRef};
+use crate::visit::GraphRef;
/// `Dot` implements output to graphviz .dot format for a graph.
///
@@ -54,7 +54,10 @@
static EDGE: [&str; 2] = ["--", "->"];
static INDENT: &str = " ";
-impl<'a, G> Dot<'a, G> where G: GraphRef {
+impl<'a, G> Dot<'a, G>
+where
+ G: GraphRef,
+{
/// Create a `Dot` formatting wrapper with default configuration.
pub fn new(graph: G) -> Self {
Self::with_config(graph, &[])
@@ -62,10 +65,7 @@
/// Create a `Dot` formatting wrapper with custom configuration.
pub fn with_config(graph: G, config: &'a [Config]) -> Self {
- Dot {
- graph,
- config,
- }
+ Dot { graph, config }
}
}
@@ -86,18 +86,23 @@
_Incomplete(()),
}
-use crate::visit::{ IntoNodeReferences, NodeIndexable, IntoEdgeReferences, EdgeRef};
-use crate::visit::{ Data, NodeRef, GraphProp, };
+use crate::visit::{Data, GraphProp, NodeRef};
+use crate::visit::{EdgeRef, IntoEdgeReferences, IntoNodeReferences, NodeIndexable};
-impl<'a, G> Dot<'a, G>
-{
- fn graph_fmt<NF, EF, NW, EW>(&self, g: G, f: &mut fmt::Formatter,
- mut node_fmt: NF, mut edge_fmt: EF) -> fmt::Result
- where G: NodeIndexable + IntoNodeReferences + IntoEdgeReferences,
- G: GraphProp,
- G: Data<NodeWeight=NW, EdgeWeight=EW>,
- NF: FnMut(&NW, &mut dyn FnMut(&dyn Display) -> fmt::Result) -> fmt::Result,
- EF: FnMut(&EW, &mut dyn FnMut(&dyn Display) -> fmt::Result) -> fmt::Result,
+impl<'a, G> Dot<'a, G> {
+ fn graph_fmt<NF, EF, NW, EW>(
+ &self,
+ g: G,
+ f: &mut fmt::Formatter,
+ mut node_fmt: NF,
+ mut edge_fmt: EF,
+ ) -> fmt::Result
+ where
+ G: NodeIndexable + IntoNodeReferences + IntoEdgeReferences,
+ G: GraphProp,
+ G: Data<NodeWeight = NW, EdgeWeight = EW>,
+ NF: FnMut(&NW, &mut dyn FnMut(&dyn Display) -> fmt::Result) -> fmt::Result,
+ EF: FnMut(&EW, &mut dyn FnMut(&dyn Display) -> fmt::Result) -> fmt::Result,
{
if !self.config.contains(&Config::GraphContentOnly) {
writeln!(f, "{} {{", TYPE[g.is_directed() as usize])?;
@@ -113,15 +118,17 @@
node_fmt(node.weight(), &mut |d| Escaped(d).fmt(f))?;
writeln!(f, "\"]")?;
}
-
}
// output all edges
for (i, edge) in g.edge_references().enumerate() {
- write!(f, "{}{} {} {}",
- INDENT,
- g.to_index(edge.source()),
- EDGE[g.is_directed() as usize],
- g.to_index(edge.target()))?;
+ write!(
+ f,
+ "{}{} {} {}",
+ INDENT,
+ g.to_index(edge.source()),
+ EDGE[g.is_directed() as usize],
+ g.to_index(edge.target())
+ )?;
if self.config.contains(&Config::EdgeNoLabel) {
writeln!(f)?;
} else if self.config.contains(&Config::EdgeIndexLabel) {
@@ -141,9 +148,10 @@
}
impl<'a, G> fmt::Display for Dot<'a, G>
- where G: IntoEdgeReferences + IntoNodeReferences + NodeIndexable + GraphProp,
- G::EdgeWeight: fmt::Display,
- G::NodeWeight: fmt::Display,
+where
+ G: IntoEdgeReferences + IntoNodeReferences + NodeIndexable + GraphProp,
+ G::EdgeWeight: fmt::Display,
+ G::NodeWeight: fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.graph_fmt(self.graph, f, |n, cb| cb(n), |e, cb| cb(e))
@@ -151,14 +159,18 @@
}
impl<'a, G> fmt::Debug for Dot<'a, G>
- where G: IntoEdgeReferences + IntoNodeReferences + NodeIndexable + GraphProp,
- G::EdgeWeight: fmt::Debug,
- G::NodeWeight: fmt::Debug,
+where
+ G: IntoEdgeReferences + IntoNodeReferences + NodeIndexable + GraphProp,
+ G::EdgeWeight: fmt::Debug,
+ G::NodeWeight: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.graph_fmt(self.graph, f,
- |n, cb| cb(&DebugFmt(n)),
- |e, cb| cb(&DebugFmt(e)))
+ self.graph_fmt(
+ self.graph,
+ f,
+ |n, cb| cb(&DebugFmt(n)),
+ |e, cb| cb(&DebugFmt(e)),
+ )
}
}
@@ -166,7 +178,8 @@
struct Escaper<W>(W);
impl<W> fmt::Write for Escaper<W>
- where W: fmt::Write
+where
+ W: fmt::Write,
{
fn write_str(&mut self, s: &str) -> fmt::Result {
for c in s.chars() {
@@ -190,7 +203,8 @@
struct Escaped<T>(T);
impl<T> fmt::Display for Escaped<T>
- where T: fmt::Display
+where
+ T: fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if f.alternate() {
@@ -205,7 +219,8 @@
struct DebugFmt<T>(T);
impl<T> fmt::Display for DebugFmt<T>
- where T: fmt::Debug
+where
+ T: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
diff --git a/src/generate.rs b/src/generate.rs
index e717239..9dc7dbf 100644
--- a/src/generate.rs
+++ b/src/generate.rs
@@ -3,8 +3,8 @@
//! ***Unstable: API may change at any time.*** Depends on `feature = "generate"`.
//!
-use crate::{Graph, Directed, EdgeType};
use crate::graph::NodeIndex;
+use crate::{Directed, EdgeType, Graph};
// A DAG has the property that the adjacency matrix is lower triangular,
// diagonal zero.
@@ -46,7 +46,7 @@
acyclic: true,
selfloops: false,
nodes: nodes,
- nedges:nedges,
+ nedges: nedges,
bits: !0,
g: Graph::with_capacity(nodes, nedges),
}
@@ -92,7 +92,11 @@
// d 3 4 5 x
let mut bit = 0;
for i in 0..self.nodes {
- let start = if self.acyclic || !self.g.is_directed() { i } else { 0 };
+ let start = if self.acyclic || !self.g.is_directed() {
+ i
+ } else {
+ 0
+ };
for j in start..self.nodes {
if i == j && !self.selfloops {
continue;
diff --git a/src/graph_impl/frozen.rs b/src/graph_impl/frozen.rs
index bb96618..1ba06d9 100644
--- a/src/graph_impl/frozen.rs
+++ b/src/graph_impl/frozen.rs
@@ -1,18 +1,15 @@
-
use std::ops::{Deref, Index, IndexMut};
-use crate::graph::Graph;
use super::Frozen;
-use crate::graph::{IndexType, GraphIndex};
-use crate::{
- Direction,
- EdgeType,
-};
-use crate::visit::{Data, IntoNodeIdentifiers, GraphProp, NodeIndexable, IntoNeighborsDirected};
-use crate::visit::{IntoNeighbors, IntoNodeReferences, IntoEdgeReferences, Visitable};
-use crate::visit::{NodeCompactIndexable, GetAdjacencyMatrix, NodeCount, IntoEdges, IntoEdgesDirected};
use crate::data::{DataMap, DataMapMut};
-
+use crate::graph::Graph;
+use crate::graph::{GraphIndex, IndexType};
+use crate::visit::{Data, GraphProp, IntoNeighborsDirected, IntoNodeIdentifiers, NodeIndexable};
+use crate::visit::{
+ GetAdjacencyMatrix, IntoEdges, IntoEdgesDirected, NodeCompactIndexable, NodeCount,
+};
+use crate::visit::{IntoEdgeReferences, IntoNeighbors, IntoNodeReferences, Visitable};
+use crate::{Direction, EdgeType};
impl<'a, G> Frozen<'a, G> {
/// Create a new `Frozen` from a mutable reference to a graph.
@@ -25,61 +22,75 @@
/// functionality in the underlying graph.
impl<'a, G> Deref for Frozen<'a, G> {
type Target = G;
- fn deref(&self) -> &G { self.0 }
+ fn deref(&self) -> &G {
+ self.0
+ }
}
impl<'a, G, I> Index<I> for Frozen<'a, G>
- where G: Index<I>
+where
+ G: Index<I>,
{
type Output = G::Output;
- fn index(&self, i: I) -> &G::Output { self.0.index(i) }
+ fn index(&self, i: I) -> &G::Output {
+ self.0.index(i)
+ }
}
impl<'a, G, I> IndexMut<I> for Frozen<'a, G>
- where G: IndexMut<I>
+where
+ G: IndexMut<I>,
{
- fn index_mut(&mut self, i: I) -> &mut G::Output { self.0.index_mut(i) }
+ fn index_mut(&mut self, i: I) -> &mut G::Output {
+ self.0.index_mut(i)
+ }
}
impl<'a, N, E, Ty, Ix> Frozen<'a, Graph<N, E, Ty, Ix>>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
/// 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.
- pub fn index_twice_mut<T, U>(&mut self, i: T, j: U)
- -> (&mut <Graph<N, E, Ty, Ix> as Index<T>>::Output,
- &mut <Graph<N, E, Ty, Ix> as Index<U>>::Output)
- where Graph<N, E, Ty, Ix>: IndexMut<T> + IndexMut<U>,
- T: GraphIndex,
- U: GraphIndex,
+ pub fn index_twice_mut<T, U>(
+ &mut self,
+ i: T,
+ j: U,
+ ) -> (
+ &mut <Graph<N, E, Ty, Ix> as Index<T>>::Output,
+ &mut <Graph<N, E, Ty, Ix> as Index<U>>::Output,
+ )
+ where
+ Graph<N, E, Ty, Ix>: IndexMut<T> + IndexMut<U>,
+ T: GraphIndex,
+ U: GraphIndex,
{
self.0.index_twice_mut(i, j)
}
}
macro_rules! access0 {
- ($e:expr) => ($e.0);
+ ($e:expr) => {
+ $e.0
+ };
}
-Data!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-DataMap!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-DataMapMut!{delegate_impl [['a, G], G, Frozen<'a, G>, access0]}
-GetAdjacencyMatrix!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-IntoEdgeReferences!{delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
-IntoEdges!{delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
-IntoEdgesDirected!{delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
-IntoNeighbors!{delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
-IntoNeighborsDirected!{delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
-IntoNodeIdentifiers!{delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
-IntoNodeReferences!{delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
-NodeCompactIndexable!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-NodeCount!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-NodeIndexable!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-GraphProp!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-Visitable!{delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
-
-
-
+Data! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
+DataMap! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
+DataMapMut! {delegate_impl [['a, G], G, Frozen<'a, G>, access0]}
+GetAdjacencyMatrix! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
+IntoEdgeReferences! {delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
+IntoEdges! {delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
+IntoEdgesDirected! {delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
+IntoNeighbors! {delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
+IntoNeighborsDirected! {delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
+IntoNodeIdentifiers! {delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
+IntoNodeReferences! {delegate_impl [['a, 'b, G], G, &'b Frozen<'a, G>, deref_twice]}
+NodeCompactIndexable! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
+NodeCount! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
+NodeIndexable! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
+GraphProp! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
+Visitable! {delegate_impl [['a, G], G, Frozen<'a, G>, deref_twice]}
diff --git a/src/graph_impl/mod.rs b/src/graph_impl/mod.rs
index 0d7a2ed..9fb43b3 100644
--- a/src/graph_impl/mod.rs
+++ b/src/graph_impl/mod.rs
@@ -7,28 +7,17 @@
use std::ops::{Index, IndexMut, Range};
use std::slice;
-use crate::{
- Direction, Outgoing, Incoming,
- Undirected,
- Directed,
- EdgeType,
- IntoWeightedEdge,
-};
+use crate::{Directed, Direction, EdgeType, Incoming, IntoWeightedEdge, Outgoing, Undirected};
-use crate::iter_format::{
- IterFormatExt,
- NoPretty,
- DebugMap,
-};
+use crate::iter_format::{DebugMap, IterFormatExt, NoPretty};
-use crate::visit::EdgeRef;
-use crate::visit::{IntoNodeReferences, IntoEdges, IntoEdgesDirected};
use crate::util::enumerate;
+use crate::visit::EdgeRef;
+use crate::visit::{IntoEdges, IntoEdgesDirected, IntoNodeReferences};
#[cfg(feature = "serde-1")]
mod serialization;
-
/// The default integer type for graph indices.
/// `u32` is the default to reduce the size of the graph's data and improve
/// performance in the common case.
@@ -41,8 +30,7 @@
///
/// Marked `unsafe` because: the trait must faithfully preserve
/// and convert index values.
-pub unsafe trait IndexType : Copy + Default + Hash + Ord + fmt::Debug + 'static
-{
+pub unsafe trait IndexType: Copy + Default + Hash + Ord + fmt::Debug + 'static {
fn new(x: usize) -> Self;
fn index(&self) -> usize;
fn max() -> Self;
@@ -50,60 +38,81 @@
unsafe impl IndexType for usize {
#[inline(always)]
- fn new(x: usize) -> Self { x }
+ fn new(x: usize) -> Self {
+ x
+ }
#[inline(always)]
- fn index(&self) -> Self { *self }
+ fn index(&self) -> Self {
+ *self
+ }
#[inline(always)]
- fn max() -> Self { ::std::usize::MAX }
+ fn max() -> Self {
+ ::std::usize::MAX
+ }
}
unsafe impl IndexType for u32 {
#[inline(always)]
- fn new(x: usize) -> Self { x as u32 }
+ fn new(x: usize) -> Self {
+ x as u32
+ }
#[inline(always)]
- fn index(&self) -> usize { *self as usize }
+ fn index(&self) -> usize {
+ *self as usize
+ }
#[inline(always)]
- fn max() -> Self { ::std::u32::MAX }
+ fn max() -> Self {
+ ::std::u32::MAX
+ }
}
unsafe impl IndexType for u16 {
#[inline(always)]
- fn new(x: usize) -> Self { x as u16 }
+ fn new(x: usize) -> Self {
+ x as u16
+ }
#[inline(always)]
- fn index(&self) -> usize { *self as usize }
+ fn index(&self) -> usize {
+ *self as usize
+ }
#[inline(always)]
- fn max() -> Self { ::std::u16::MAX }
+ fn max() -> Self {
+ ::std::u16::MAX
+ }
}
unsafe impl IndexType for u8 {
#[inline(always)]
- fn new(x: usize) -> Self { x as u8 }
+ fn new(x: usize) -> Self {
+ x as u8
+ }
#[inline(always)]
- fn index(&self) -> usize { *self as usize }
+ fn index(&self) -> usize {
+ *self as usize
+ }
#[inline(always)]
- fn max() -> Self { ::std::u8::MAX }
+ fn max() -> Self {
+ ::std::u8::MAX
+ }
}
/// Node identifier.
#[derive(Copy, Clone, Default, PartialEq, PartialOrd, Eq, Ord, Hash)]
-pub struct NodeIndex<Ix=DefaultIx>(Ix);
+pub struct NodeIndex<Ix = DefaultIx>(Ix);
-impl<Ix: IndexType> NodeIndex<Ix>
-{
+impl<Ix: IndexType> NodeIndex<Ix> {
#[inline]
pub fn new(x: usize) -> Self {
NodeIndex(IndexType::new(x))
}
#[inline]
- pub fn index(self) -> usize
- {
+ pub fn index(self) -> usize {
self.0.index()
}
#[inline]
- pub fn end() -> Self
- {
+ pub fn end() -> Self {
NodeIndex(IndexType::max())
}
@@ -113,36 +122,39 @@
}
impl<Ix: IndexType> From<Ix> for NodeIndex<Ix> {
- fn from(ix: Ix) -> Self { NodeIndex(ix) }
+ fn from(ix: Ix) -> Self {
+ NodeIndex(ix)
+ }
}
-impl<Ix: fmt::Debug> fmt::Debug for NodeIndex<Ix>
-{
+impl<Ix: fmt::Debug> fmt::Debug for NodeIndex<Ix> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "NodeIndex({:?})", self.0)
}
}
/// Short version of `NodeIndex::new`
-pub fn node_index<Ix: IndexType>(index: usize) -> NodeIndex<Ix> { NodeIndex::new(index) }
+pub fn node_index<Ix: IndexType>(index: usize) -> NodeIndex<Ix> {
+ NodeIndex::new(index)
+}
/// Short version of `EdgeIndex::new`
-pub fn edge_index<Ix: IndexType>(index: usize) -> EdgeIndex<Ix> { EdgeIndex::new(index) }
+pub fn edge_index<Ix: IndexType>(index: usize) -> EdgeIndex<Ix> {
+ EdgeIndex::new(index)
+}
/// Edge identifier.
#[derive(Copy, Clone, Default, PartialEq, PartialOrd, Eq, Ord, Hash)]
-pub struct EdgeIndex<Ix=DefaultIx>(Ix);
+pub struct EdgeIndex<Ix = DefaultIx>(Ix);
-impl<Ix: IndexType> EdgeIndex<Ix>
-{
+impl<Ix: IndexType> EdgeIndex<Ix> {
#[inline]
pub fn new(x: usize) -> Self {
EdgeIndex(IndexType::new(x))
}
#[inline]
- pub fn index(self) -> usize
- {
+ pub fn index(self) -> usize {
self.0.index()
}
@@ -159,11 +171,12 @@
}
impl<Ix: IndexType> From<Ix> for EdgeIndex<Ix> {
- fn from(ix: Ix) -> Self { EdgeIndex(ix) }
+ fn from(ix: Ix) -> Self {
+ EdgeIndex(ix)
+ }
}
-impl<Ix: fmt::Debug> fmt::Debug for EdgeIndex<Ix>
-{
+impl<Ix: fmt::Debug> fmt::Debug for EdgeIndex<Ix> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "EdgeIndex({:?})", self.0)
}
@@ -195,24 +208,21 @@
next: [EdgeIndex<Ix>; 2],
}
-impl<E, Ix> Clone for Node<E, Ix> where E: Clone, Ix: Copy {
- clone_fields!(Node,
- weight,
- next,
- );
+impl<E, Ix> Clone for Node<E, Ix>
+where
+ E: Clone,
+ Ix: Copy,
+{
+ clone_fields!(Node, weight, next,);
}
-
-impl<N, Ix: IndexType> Node<N, Ix>
-{
+impl<N, Ix: IndexType> Node<N, Ix> {
/// Accessor for data structure internals: the first edge in the given direction.
- pub fn next_edge(&self, dir: Direction) -> EdgeIndex<Ix>
- {
+ pub fn next_edge(&self, dir: Direction) -> EdgeIndex<Ix> {
self.next[dir.index()]
}
}
-
/// The graph's edge type.
#[derive(Debug)]
pub struct Edge<E, Ix = DefaultIx> {
@@ -224,31 +234,27 @@
node: [NodeIndex<Ix>; 2],
}
-impl<E, Ix> Clone for Edge<E, Ix> where E: Clone, Ix: Copy {
- clone_fields!(Edge,
- weight,
- next,
- node,
- );
+impl<E, Ix> Clone for Edge<E, Ix>
+where
+ E: Clone,
+ Ix: Copy,
+{
+ clone_fields!(Edge, weight, next, node,);
}
-impl<E, Ix: IndexType> Edge<E, Ix>
-{
+impl<E, Ix: IndexType> Edge<E, Ix> {
/// Accessor for data structure internals: the next edge for the given direction.
- pub fn next_edge(&self, dir: Direction) -> EdgeIndex<Ix>
- {
+ pub fn next_edge(&self, dir: Direction) -> EdgeIndex<Ix> {
self.next[dir.index()]
}
/// Return the source node index.
- pub fn source(&self) -> NodeIndex<Ix>
- {
+ pub fn source(&self) -> NodeIndex<Ix> {
self.node[0]
}
/// Return the target node index.
- pub fn target(&self) -> NodeIndex<Ix>
- {
+ pub fn target(&self) -> NodeIndex<Ix> {
self.node[1]
}
}
@@ -341,10 +347,11 @@
/// *2* and *1*.
pub type UnGraph<N, E, Ix = DefaultIx> = Graph<N, E, Undirected, Ix>;
-
/// The resulting cloned graph has the same graph indices as `self`.
impl<N, E, Ty, Ix: IndexType> Clone for Graph<N, E, Ty, Ix>
- where N: Clone, E: Clone,
+where
+ N: Clone,
+ E: Clone,
{
fn clone(&self) -> Self {
Graph {
@@ -362,34 +369,44 @@
}
impl<N, E, Ty, Ix> fmt::Debug for Graph<N, E, Ty, Ix>
- where N: fmt::Debug,
- E: fmt::Debug,
- Ty: EdgeType,
- Ix: IndexType,
+where
+ N: fmt::Debug,
+ E: fmt::Debug,
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let etype = if self.is_directed() { "Directed" } else { "Undirected" };
+ let etype = if self.is_directed() {
+ "Directed"
+ } else {
+ "Undirected"
+ };
let mut fmt_struct = f.debug_struct("Graph");
fmt_struct.field("Ty", &etype);
fmt_struct.field("node_count", &self.node_count());
fmt_struct.field("edge_count", &self.edge_count());
if self.edge_count() > 0 {
- fmt_struct.field("edges",
- &self.edges
- .iter()
- .map(|e| NoPretty((e.source().index(), e.target().index())))
- .format(", "));
+ fmt_struct.field(
+ "edges",
+ &self
+ .edges
+ .iter()
+ .map(|e| NoPretty((e.source().index(), e.target().index())))
+ .format(", "),
+ );
}
// skip weights if they are ZST!
if size_of::<N>() != 0 {
- fmt_struct.field("node weights", &DebugMap(|| self.nodes.iter()
- .map(|n| &n.weight)
- .enumerate()));
+ fmt_struct.field(
+ "node weights",
+ &DebugMap(|| self.nodes.iter().map(|n| &n.weight).enumerate()),
+ );
}
if size_of::<E>() != 0 {
- fmt_struct.field("edge weights", &DebugMap(|| self.edges.iter()
- .map(|n| &n.weight)
- .enumerate()));
+ fmt_struct.field(
+ "edge weights",
+ &DebugMap(|| self.edges.iter().map(|n| &n.weight).enumerate()),
+ );
}
fmt_struct.finish()
}
@@ -419,63 +436,65 @@
}
}
-impl<N, E> Graph<N, E, Directed>
-{
+impl<N, E> Graph<N, E, Directed> {
/// Create a new `Graph` with directed edges.
///
/// This is a convenience method. Use `Graph::with_capacity` or `Graph::default` for
/// a constructor that is generic in all the type parameters of `Graph`.
- pub fn new() -> Self
- {
- Graph{nodes: Vec::new(), edges: Vec::new(),
- ty: PhantomData}
+ pub fn new() -> Self {
+ Graph {
+ nodes: Vec::new(),
+ edges: Vec::new(),
+ ty: PhantomData,
+ }
}
}
-impl<N, E> Graph<N, E, Undirected>
-{
+impl<N, E> Graph<N, E, Undirected> {
/// Create a new `Graph` with undirected edges.
///
/// This is a convenience method. Use `Graph::with_capacity` or `Graph::default` for
/// a constructor that is generic in all the type parameters of `Graph`.
- pub fn new_undirected() -> Self
- {
- Graph{nodes: Vec::new(), edges: Vec::new(),
- ty: PhantomData}
+ pub fn new_undirected() -> Self {
+ Graph {
+ nodes: Vec::new(),
+ edges: Vec::new(),
+ ty: PhantomData,
+ }
}
}
impl<N, E, Ty, Ix> Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
/// Create a new `Graph` with estimated capacity.
- pub fn with_capacity(nodes: usize, edges: usize) -> Self
- {
- Graph{nodes: Vec::with_capacity(nodes), edges: Vec::with_capacity(edges),
- ty: PhantomData}
+ pub fn with_capacity(nodes: usize, edges: usize) -> Self {
+ Graph {
+ nodes: Vec::with_capacity(nodes),
+ edges: Vec::with_capacity(edges),
+ ty: PhantomData,
+ }
}
/// Return the number of nodes (vertices) in the graph.
///
/// Computes in **O(1)** time.
- pub fn node_count(&self) -> usize
- {
+ pub fn node_count(&self) -> usize {
self.nodes.len()
}
/// Return the number of edges in the graph.
///
/// Computes in **O(1)** time.
- pub fn edge_count(&self) -> usize
- {
+ pub fn edge_count(&self) -> usize {
self.edges.len()
}
/// Whether the graph has directed edges or not.
#[inline]
- pub fn is_directed(&self) -> bool
- {
+ pub fn is_directed(&self) -> bool {
Ty::is_directed()
}
@@ -487,9 +506,11 @@
///
/// **Panics** if the Graph is at the maximum number of nodes for its index
/// type (N/A if usize).
- pub fn add_node(&mut self, weight: N) -> NodeIndex<Ix>
- {
- let node = Node{weight, next: [EdgeIndex::end(), EdgeIndex::end()]};
+ pub fn add_node(&mut self, weight: N) -> NodeIndex<Ix> {
+ let node = Node {
+ weight,
+ next: [EdgeIndex::end(), EdgeIndex::end()],
+ };
let node_idx = NodeIndex::new(self.nodes.len());
// check for max capacity, except if we use usize
assert!(<Ix as IndexType>::max().index() == !0 || NodeIndex::end() != node_idx);
@@ -500,16 +521,14 @@
/// Access the weight for node `a`.
///
/// Also available with indexing syntax: `&graph[a]`.
- pub fn node_weight(&self, a: NodeIndex<Ix>) -> Option<&N>
- {
+ pub fn node_weight(&self, a: NodeIndex<Ix>) -> Option<&N> {
self.nodes.get(a.index()).map(|n| &n.weight)
}
/// Access the weight for node `a`, mutably.
///
/// Also available with indexing syntax: `&mut graph[a]`.
- pub fn node_weight_mut(&mut self, a: NodeIndex<Ix>) -> Option<&mut N>
- {
+ pub fn node_weight_mut(&mut self, a: NodeIndex<Ix>) -> Option<&mut N> {
self.nodes.get_mut(a.index()).map(|n| &mut n.weight)
}
@@ -526,8 +545,7 @@
///
/// **Note:** `Graph` allows adding parallel (“duplicate”) edges. If you want
/// to avoid this, use [`.update_edge(a, b, weight)`](#method.update_edge) instead.
- pub fn add_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E) -> EdgeIndex<Ix>
- {
+ pub fn add_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E) -> EdgeIndex<Ix> {
let edge_idx = EdgeIndex::new(self.edges.len());
assert!(<Ix as IndexType>::max().index() == !0 || EdgeIndex::end() != edge_idx);
let mut edge = Edge {
@@ -562,8 +580,7 @@
/// connected to `a` (and `b`, if the graph edges are undirected).
///
/// **Panics** if any of the nodes don't exist.
- pub fn update_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E) -> EdgeIndex<Ix>
- {
+ pub fn update_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E) -> EdgeIndex<Ix> {
if let Some(ix) = self.find_edge(a, b) {
if let Some(ed) = self.edge_weight_mut(ix) {
*ed = weight;
@@ -576,24 +593,22 @@
/// Access the weight for edge `e`.
///
/// Also available with indexing syntax: `&graph[e]`.
- pub fn edge_weight(&self, e: EdgeIndex<Ix>) -> Option<&E>
- {
+ pub fn edge_weight(&self, e: EdgeIndex<Ix>) -> Option<&E> {
self.edges.get(e.index()).map(|ed| &ed.weight)
}
/// Access the weight for edge `e`, mutably.
///
/// Also available with indexing syntax: `&mut graph[e]`.
- pub fn edge_weight_mut(&mut self, e: EdgeIndex<Ix>) -> Option<&mut E>
- {
+ pub fn edge_weight_mut(&mut self, e: EdgeIndex<Ix>) -> Option<&mut E> {
self.edges.get_mut(e.index()).map(|ed| &mut ed.weight)
}
/// Access the source and target nodes for `e`.
- pub fn edge_endpoints(&self, e: EdgeIndex<Ix>)
- -> Option<(NodeIndex<Ix>, NodeIndex<Ix>)>
- {
- self.edges.get(e.index()).map(|ed| (ed.source(), ed.target()))
+ pub fn edge_endpoints(&self, e: EdgeIndex<Ix>) -> Option<(NodeIndex<Ix>, NodeIndex<Ix>)> {
+ self.edges
+ .get(e.index())
+ .map(|ed| (ed.source(), ed.target()))
}
/// Remove `a` from the graph if it exists, and return its weight.
@@ -608,8 +623,7 @@
/// edges, including *n* calls to `.remove_edge()` where *n* is the number
/// of edges with an endpoint in `a`, and including the edges with an
/// endpoint in the displaced node.
- pub fn remove_node(&mut self, a: NodeIndex<Ix>) -> Option<N>
- {
+ pub fn remove_node(&mut self, a: NodeIndex<Ix>) -> Option<N> {
self.nodes.get(a.index())?;
for d in &DIRECTIONS {
let k = d.index();
@@ -618,7 +632,7 @@
loop {
let next = self.nodes[a.index()].next[k];
if next == EdgeIndex::end() {
- break
+ break;
}
let ret = self.remove_edge(next);
debug_assert!(ret.is_some());
@@ -656,17 +670,23 @@
/// For edge `e` with endpoints `edge_node`, replace links to it,
/// with links to `edge_next`.
- fn change_edge_links(&mut self, edge_node: [NodeIndex<Ix>; 2], e: EdgeIndex<Ix>,
- edge_next: [EdgeIndex<Ix>; 2])
- {
+ fn change_edge_links(
+ &mut self,
+ edge_node: [NodeIndex<Ix>; 2],
+ e: EdgeIndex<Ix>,
+ edge_next: [EdgeIndex<Ix>; 2],
+ ) {
for &d in &DIRECTIONS {
let k = d.index();
let node = match self.nodes.get_mut(edge_node[k].index()) {
Some(r) => r,
None => {
- debug_assert!(false, "Edge's endpoint dir={:?} index={:?} not found",
- d, edge_node[k]);
- return
+ debug_assert!(
+ false,
+ "Edge's endpoint dir={:?} index={:?} not found",
+ d, edge_node[k]
+ );
+ return;
}
};
let fst = node.next[k];
@@ -692,8 +712,7 @@
///
/// Computes in **O(e')** time, where **e'** is the size of four particular edge lists, for
/// the vertices of `e` and the vertices of another affected edge.
- pub fn remove_edge(&mut self, e: EdgeIndex<Ix>) -> Option<E>
- {
+ pub fn remove_edge(&mut self, e: EdgeIndex<Ix>) -> Option<E> {
// every edge is part of two lists,
// outgoing and incoming edges.
// Remove it from both
@@ -707,8 +726,7 @@
self.remove_edge_adjust_indices(e)
}
- fn remove_edge_adjust_indices(&mut self, e: EdgeIndex<Ix>) -> Option<E>
- {
+ fn remove_edge_adjust_indices(&mut self, e: EdgeIndex<Ix>) -> Option<E> {
// swap_remove the edge -- only the removed edge
// and the edge swapped into place are affected and need updating
// indices.
@@ -738,8 +756,7 @@
/// not borrow from the graph.
///
/// [1]: struct.Neighbors.html#method.detach
- pub fn neighbors(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix>
- {
+ pub fn neighbors(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix> {
self.neighbors_directed(a, Outgoing)
}
@@ -762,8 +779,7 @@
/// not borrow from the graph.
///
/// [1]: struct.Neighbors.html#method.detach
- pub fn neighbors_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Neighbors<E, Ix>
- {
+ pub fn neighbors_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Neighbors<E, Ix> {
let mut iter = self.neighbors_undirected(a);
if self.is_directed() {
let k = dir.index();
@@ -787,15 +803,14 @@
///
/// [1]: struct.Neighbors.html#method.detach
///
- pub fn neighbors_undirected(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix>
- {
+ pub fn neighbors_undirected(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix> {
Neighbors {
skip_start: a,
edges: &self.edges,
next: match self.nodes.get(a.index()) {
None => [EdgeIndex::end(), EdgeIndex::end()],
Some(n) => n.next,
- }
+ },
}
}
@@ -821,8 +836,7 @@
///
/// Produces an empty iterator if the node `a` doesn't exist.<br>
/// Iterator element type is `EdgeReference<E, Ix>`.
- pub fn edges_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Edges<E, Ty, Ix>
- {
+ pub fn edges_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Edges<E, Ty, Ix> {
Edges {
skip_start: a,
edges: &self.edges,
@@ -841,8 +855,11 @@
/// - `Undirected`: All edges connected to `a`.
///
/// Iterator element type is `EdgeReference<E, Ix>`.
- pub fn edges_connecting(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> EdgesConnecting<E, Ty, Ix>
- {
+ pub fn edges_connecting(
+ &self,
+ a: NodeIndex<Ix>,
+ b: NodeIndex<Ix>,
+ ) -> EdgesConnecting<E, Ty, Ix> {
EdgesConnecting {
target_node: b,
edges: self.edges_directed(a, Direction::Outgoing),
@@ -862,25 +879,26 @@
///
/// Computes in **O(e')** time, where **e'** is the number of edges
/// connected to `a` (and `b`, if the graph edges are undirected).
- pub fn find_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> Option<EdgeIndex<Ix>>
- {
+ pub fn find_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> Option<EdgeIndex<Ix>> {
if !self.is_directed() {
self.find_edge_undirected(a, b).map(|(ix, _)| ix)
} else {
match self.nodes.get(a.index()) {
None => None,
- Some(node) => self.find_edge_directed_from_node(node, b)
+ Some(node) => self.find_edge_directed_from_node(node, b),
}
}
}
- fn find_edge_directed_from_node(&self, node: &Node<N, Ix>, b: NodeIndex<Ix>)
- -> Option<EdgeIndex<Ix>>
- {
+ fn find_edge_directed_from_node(
+ &self,
+ node: &Node<N, Ix>,
+ b: NodeIndex<Ix>,
+ ) -> Option<EdgeIndex<Ix>> {
let mut edix = node.next[0];
while let Some(edge) = self.edges.get(edix.index()) {
if edge.node[1] == b {
- return Some(edix)
+ return Some(edix);
}
edix = edge.next[0];
}
@@ -894,23 +912,28 @@
/// 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.
- pub fn find_edge_undirected(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> Option<(EdgeIndex<Ix>, Direction)>
- {
+ pub fn find_edge_undirected(
+ &self,
+ a: NodeIndex<Ix>,
+ b: NodeIndex<Ix>,
+ ) -> Option<(EdgeIndex<Ix>, Direction)> {
match self.nodes.get(a.index()) {
None => None,
Some(node) => self.find_edge_undirected_from_node(node, b),
}
}
- fn find_edge_undirected_from_node(&self, node: &Node<N, Ix>, b: NodeIndex<Ix>)
- -> Option<(EdgeIndex<Ix>, Direction)>
- {
+ fn find_edge_undirected_from_node(
+ &self,
+ node: &Node<N, Ix>,
+ b: NodeIndex<Ix>,
+ ) -> Option<(EdgeIndex<Ix>, Direction)> {
for &d in &DIRECTIONS {
let k = d.index();
let mut edix = node.next[k];
while let Some(edge) = self.edges.get(edix.index()) {
if edge.node[1 - k] == b {
- return Some((edix, d))
+ return Some((edix, d));
}
edix = edge.next[k];
}
@@ -929,9 +952,12 @@
/// just the nodes without edges.
///
/// The whole iteration computes in **O(|V|)** time.
- pub fn externals(&self, dir: Direction) -> Externals<N, Ty, Ix>
- {
- Externals{iter: self.nodes.iter().enumerate(), dir, ty: PhantomData}
+ pub fn externals(&self, dir: Direction) -> Externals<N, Ty, Ix> {
+ Externals {
+ iter: self.nodes.iter().enumerate(),
+ dir,
+ ty: PhantomData,
+ }
}
/// Return an iterator over the node indices of the graph.
@@ -947,21 +973,28 @@
/// let index = g.node_indices().find(|i| g[*i] == "book").unwrap();
/// ```
pub fn node_indices(&self) -> NodeIndices<Ix> {
- NodeIndices { r: 0..self.node_count(), ty: PhantomData }
+ NodeIndices {
+ r: 0..self.node_count(),
+ ty: PhantomData,
+ }
}
/// Return an iterator yielding mutable access to all node weights.
///
/// The order in which weights are yielded matches the order of their
/// node indices.
- pub fn node_weights_mut(&mut self) -> NodeWeightsMut<N, Ix>
- {
- NodeWeightsMut { nodes: self.nodes.iter_mut() }
+ pub fn node_weights_mut(&mut self) -> NodeWeightsMut<N, Ix> {
+ NodeWeightsMut {
+ nodes: self.nodes.iter_mut(),
+ }
}
/// Return an iterator over the edge indices of the graph
pub fn edge_indices(&self) -> EdgeIndices<Ix> {
- EdgeIndices { r: 0..self.edge_count(), ty: PhantomData }
+ EdgeIndices {
+ r: 0..self.edge_count(),
+ ty: PhantomData,
+ }
}
/// Create an iterator over all edges, in indexed order.
@@ -969,7 +1002,7 @@
/// Iterator element type is `EdgeReference<E, Ix>`.
pub fn edge_references(&self) -> EdgeReferences<E, Ix> {
EdgeReferences {
- iter: self.edges.iter().enumerate()
+ iter: self.edges.iter().enumerate(),
}
}
@@ -977,23 +1010,22 @@
///
/// The order in which weights are yielded matches the order of their
/// edge indices.
- pub fn edge_weights_mut(&mut self) -> EdgeWeightsMut<E, Ix>
- {
- EdgeWeightsMut { edges: self.edges.iter_mut() }
+ pub fn edge_weights_mut(&mut self) -> EdgeWeightsMut<E, Ix> {
+ EdgeWeightsMut {
+ edges: self.edges.iter_mut(),
+ }
}
// Remaining methods are of the more internal flavour, read-only access to
// the data structure's internals.
/// Access the internal node array.
- pub fn raw_nodes(&self) -> &[Node<N, Ix>]
- {
+ pub fn raw_nodes(&self) -> &[Node<N, Ix>] {
&self.nodes
}
/// Access the internal edge array.
- pub fn raw_edges(&self) -> &[Edge<E, Ix>]
- {
+ pub fn raw_edges(&self) -> &[Edge<E, Ix>] {
&self.edges
}
@@ -1003,29 +1035,31 @@
}
/// Accessor for data structure internals: the first edge in the given direction.
- pub fn first_edge(&self, a: NodeIndex<Ix>, dir: Direction) -> Option<EdgeIndex<Ix>>
- {
+ pub fn first_edge(&self, a: NodeIndex<Ix>, dir: Direction) -> Option<EdgeIndex<Ix>> {
match self.nodes.get(a.index()) {
None => None,
Some(node) => {
let edix = node.next[dir.index()];
if edix == EdgeIndex::end() {
None
- } else { Some(edix) }
+ } else {
+ Some(edix)
+ }
}
}
}
/// Accessor for data structure internals: the next edge for the given direction.
- pub fn next_edge(&self, e: EdgeIndex<Ix>, dir: Direction) -> Option<EdgeIndex<Ix>>
- {
+ pub fn next_edge(&self, e: EdgeIndex<Ix>, dir: Direction) -> Option<EdgeIndex<Ix>> {
match self.edges.get(e.index()) {
None => None,
Some(node) => {
let edix = node.next[dir.index()];
if edix == EdgeIndex::end() {
None
- } else { Some(edix) }
+ } else {
+ Some(edix)
+ }
}
}
}
@@ -1063,21 +1097,28 @@
/// assert_eq!(gr[b], 4.);
/// assert_eq!(gr[c], 2.);
/// ```
- pub fn index_twice_mut<T, U>(&mut self, i: T, j: U)
- -> (&mut <Self as Index<T>>::Output,
- &mut <Self as Index<U>>::Output)
- where Self: IndexMut<T> + IndexMut<U>,
- T: GraphIndex,
- U: GraphIndex,
+ pub fn index_twice_mut<T, U>(
+ &mut self,
+ i: T,
+ j: U,
+ ) -> (
+ &mut <Self as Index<T>>::Output,
+ &mut <Self as Index<U>>::Output,
+ )
+ where
+ Self: IndexMut<T> + IndexMut<U>,
+ T: GraphIndex,
+ U: GraphIndex,
{
- assert!(T::is_node_index() != U::is_node_index() ||
- i.index() != j.index());
+ assert!(T::is_node_index() != U::is_node_index() || i.index() != j.index());
// Allow two mutable indexes here -- they are nonoverlapping
unsafe {
let self_mut = self as *mut _;
- (<Self as IndexMut<T>>::index_mut(&mut *self_mut, i),
- <Self as IndexMut<U>>::index_mut(&mut *self_mut, j))
+ (
+ <Self as IndexMut<T>>::index_mut(&mut *self_mut, i),
+ <Self as IndexMut<U>>::index_mut(&mut *self_mut, j),
+ )
}
}
@@ -1176,7 +1217,8 @@
///
/// The order nodes are visited is not specified.
pub fn retain_nodes<F>(&mut self, mut visit: F)
- where F: FnMut(Frozen<Self>, NodeIndex<Ix>) -> bool
+ where
+ F: FnMut(Frozen<Self>, NodeIndex<Ix>) -> bool,
{
for index in self.node_indices().rev() {
if !visit(Frozen(self), index) {
@@ -1195,7 +1237,8 @@
///
/// The order edges are visited is not specified.
pub fn retain_edges<F>(&mut self, mut visit: F)
- where F: FnMut(Frozen<Self>, EdgeIndex<Ix>) -> bool
+ where
+ F: FnMut(Frozen<Self>, EdgeIndex<Ix>) -> bool,
{
for index in self.edge_indices().rev() {
if !visit(Frozen(self), index) {
@@ -1206,7 +1249,6 @@
}
}
-
/// Create a new `Graph` from an iterable of edges.
///
/// Node weights `N` are set to default values.
@@ -1225,10 +1267,11 @@
/// ]);
/// ```
pub fn from_edges<I>(iterable: I) -> Self
- where I: IntoIterator,
- I::Item: IntoWeightedEdge<E>,
- <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
- N: Default,
+ where
+ I: IntoIterator,
+ I::Item: IntoWeightedEdge<E>,
+ <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
+ N: Default,
{
let mut g = Self::with_capacity(0, 0);
g.extend_with_edges(iterable);
@@ -1243,10 +1286,11 @@
///
/// Nodes are inserted automatically to match the edges.
pub fn extend_with_edges<I>(&mut self, iterable: I)
- where I: IntoIterator,
- I::Item: IntoWeightedEdge<E>,
- <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
- N: Default,
+ where
+ I: IntoIterator,
+ I::Item: IntoWeightedEdge<E>,
+ <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
+ N: Default,
{
let iter = iterable.into_iter();
let (low, _) = iter.size_hint();
@@ -1263,29 +1307,30 @@
}
}
-
/// Create a new `Graph` by mapping node and
/// edge weights to new values.
///
/// The resulting graph has the same structure and the same
/// graph indices as `self`.
- pub fn map<'a, F, G, N2, E2>(&'a self, mut node_map: F, mut edge_map: G)
- -> Graph<N2, E2, Ty, Ix>
- where F: FnMut(NodeIndex<Ix>, &'a N) -> N2,
- G: FnMut(EdgeIndex<Ix>, &'a E) -> E2,
+ pub fn map<'a, F, G, N2, E2>(
+ &'a self,
+ mut node_map: F,
+ mut edge_map: G,
+ ) -> Graph<N2, E2, Ty, Ix>
+ where
+ F: FnMut(NodeIndex<Ix>, &'a N) -> N2,
+ G: FnMut(EdgeIndex<Ix>, &'a E) -> E2,
{
let mut g = Graph::with_capacity(self.node_count(), self.edge_count());
- g.nodes.extend(enumerate(&self.nodes).map(|(i, node)|
- Node {
- weight: node_map(NodeIndex::new(i), &node.weight),
- next: node.next,
- }));
- g.edges.extend(enumerate(&self.edges).map(|(i, edge)|
- Edge {
- weight: edge_map(EdgeIndex::new(i), &edge.weight),
- next: edge.next,
- node: edge.node,
- }));
+ g.nodes.extend(enumerate(&self.nodes).map(|(i, node)| Node {
+ weight: node_map(NodeIndex::new(i), &node.weight),
+ next: node.next,
+ }));
+ g.edges.extend(enumerate(&self.edges).map(|(i, edge)| Edge {
+ weight: edge_map(EdgeIndex::new(i), &edge.weight),
+ next: edge.next,
+ node: edge.node,
+ }));
g
}
@@ -1301,10 +1346,14 @@
/// If no nodes are removed, the resulting graph has compatible node
/// indices; if neither nodes nor edges are removed, the result has
/// the same graph indices as `self`.
- pub fn filter_map<'a, F, G, N2, E2>(&'a self, mut node_map: F, mut edge_map: G)
- -> Graph<N2, E2, Ty, Ix>
- where F: FnMut(NodeIndex<Ix>, &'a N) -> Option<N2>,
- G: FnMut(EdgeIndex<Ix>, &'a E) -> Option<E2>,
+ pub fn filter_map<'a, F, G, N2, E2>(
+ &'a self,
+ mut node_map: F,
+ mut edge_map: G,
+ ) -> Graph<N2, E2, Ty, Ix>
+ where
+ F: FnMut(NodeIndex<Ix>, &'a N) -> Option<N2>,
+ G: FnMut(EdgeIndex<Ix>, &'a E) -> Option<E2>,
{
let mut g = Graph::with_capacity(0, 0);
// mapping from old node index to new node index, end represents removed.
@@ -1331,14 +1380,17 @@
/// are done, so you may want to go over the result to remove or add edges.
///
/// Computes in **O(1)** time.
- pub fn into_edge_type<NewTy>(self) -> Graph<N, E, NewTy, Ix> where
- NewTy: EdgeType
+ pub fn into_edge_type<NewTy>(self) -> Graph<N, E, NewTy, Ix>
+ where
+ NewTy: EdgeType,
{
- Graph{nodes: self.nodes, edges: self.edges,
- ty: PhantomData}
+ Graph {
+ nodes: self.nodes,
+ edges: self.edges,
+ ty: PhantomData,
+ }
}
-
//
// internal methods
//
@@ -1375,26 +1427,26 @@
ty: PhantomData<Ty>,
}
-impl<'a, N: 'a, Ty, Ix> Iterator for Externals<'a, N, Ty, Ix> where
+impl<'a, N: 'a, Ty, Ix> Iterator for Externals<'a, N, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
type Item = NodeIndex<Ix>;
- fn next(&mut self) -> Option<NodeIndex<Ix>>
- {
+ fn next(&mut self) -> Option<NodeIndex<Ix>> {
let k = self.dir.index();
loop {
match self.iter.next() {
None => return None,
Some((index, node)) => {
- if node.next[k] == EdgeIndex::end() &&
- (Ty::is_directed() ||
- node.next[1-k] == EdgeIndex::end()) {
- return Some(NodeIndex::new(index))
+ if node.next[k] == EdgeIndex::end()
+ && (Ty::is_directed() || node.next[1 - k] == EdgeIndex::end())
+ {
+ return Some(NodeIndex::new(index));
} else {
- continue
+ continue;
}
- },
+ }
}
}
}
@@ -1410,15 +1462,15 @@
/// [1]: struct.Graph.html#method.neighbors
/// [2]: struct.Graph.html#method.neighbors_directed
/// [3]: struct.Graph.html#method.neighbors_undirected
-pub struct Neighbors<'a, E: 'a, Ix: 'a = DefaultIx>
-{
+pub struct Neighbors<'a, E: 'a, Ix: 'a = DefaultIx> {
/// starting node to skip over
skip_start: NodeIndex<Ix>,
edges: &'a [Edge<E, Ix>],
next: [EdgeIndex<Ix>; 2],
}
-impl<'a, E, Ix> Iterator for Neighbors<'a, E, Ix> where
+impl<'a, E, Ix> Iterator for Neighbors<'a, E, Ix>
+where
Ix: IndexType,
{
type Item = NodeIndex<Ix>;
@@ -1446,19 +1498,16 @@
}
}
-
impl<'a, E, Ix> Clone for Neighbors<'a, E, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
- clone_fields!(Neighbors,
- skip_start,
- edges,
- next,
- );
+ clone_fields!(Neighbors, skip_start, edges, next,);
}
impl<'a, E, Ix> Neighbors<'a, E, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
/// Return a “walker” object that can be used to step through the
/// neighbors and edges from the origin node.
@@ -1468,7 +1517,7 @@
pub fn detach(&self) -> WalkNeighbors<Ix> {
WalkNeighbors {
skip_start: self.skip_start,
- next: self.next
+ next: self.next,
}
}
}
@@ -1479,18 +1528,19 @@
dir: Direction,
}
-fn edges_walker_mut<E, Ix>(edges: &mut [Edge<E, Ix>], next: EdgeIndex<Ix>, dir: Direction)
- -> EdgesWalkerMut<E, Ix>
- where Ix: IndexType,
+fn edges_walker_mut<E, Ix>(
+ edges: &mut [Edge<E, Ix>],
+ next: EdgeIndex<Ix>,
+ dir: Direction,
+) -> EdgesWalkerMut<E, Ix>
+where
+ Ix: IndexType,
{
- EdgesWalkerMut {
- edges,
- next,
- dir
- }
+ EdgesWalkerMut { edges, next, dir }
}
-impl<'a, E, Ix> EdgesWalkerMut<'a, E, Ix> where
+impl<'a, E, Ix> EdgesWalkerMut<'a, E, Ix>
+where
Ix: IndexType,
{
fn next_edge(&mut self) -> Option<&mut Edge<E, Ix>> {
@@ -1510,10 +1560,10 @@
}
}
-
impl<'a, N, E, Ty, Ix> IntoEdges for &'a Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Edges = Edges<'a, E, Ty, Ix>;
fn edges(self, a: Self::NodeId) -> Self::Edges {
@@ -1522,8 +1572,9 @@
}
impl<'a, N, E, Ty, Ix> IntoEdgesDirected for &'a Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgesDirected = Edges<'a, E, Ty, Ix>;
fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::EdgesDirected {
@@ -1531,11 +1582,11 @@
}
}
-
/// Iterator over the edges of from or to a node
pub struct Edges<'a, E: 'a, Ty, Ix: 'a = DefaultIx>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
/// starting node to skip over
skip_start: NodeIndex<Ix>,
@@ -1551,8 +1602,9 @@
}
impl<'a, E, Ty, Ix> Iterator for Edges<'a, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Item = EdgeReference<'a, E, Ix>;
@@ -1606,7 +1658,7 @@
*node
},
weight,
- })
+ });
}
}
@@ -1616,8 +1668,9 @@
/// Iterator over the multiple directed edges connecting a source node to a target node
pub struct EdgesConnecting<'a, E: 'a, Ty, Ix: 'a = DefaultIx>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
target_node: NodeIndex<Ix>,
edges: Edges<'a, E, Ty, Ix>,
@@ -1625,8 +1678,9 @@
}
impl<'a, E, Ty, Ix> Iterator for EdgesConnecting<'a, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Item = EdgeReference<'a, E, Ix>;
@@ -1641,15 +1695,15 @@
}
}
-
fn swap_pair<T>(mut x: [T; 2]) -> [T; 2] {
x.swap(0, 1);
x
}
impl<'a, E, Ty, Ix> Clone for Edges<'a, E, Ty, Ix>
- where Ix: IndexType,
- Ty: EdgeType,
+where
+ Ix: IndexType,
+ Ty: EdgeType,
{
fn clone(&self) -> Self {
Edges {
@@ -1667,7 +1721,8 @@
nodes: ::std::slice::IterMut<'a, Node<N, Ix>>,
}
-impl<'a, N, Ix> Iterator for NodeWeightsMut<'a, N, Ix> where
+impl<'a, N, Ix> Iterator for NodeWeightsMut<'a, N, Ix>
+where
Ix: IndexType,
{
type Item = &'a mut N;
@@ -1686,7 +1741,8 @@
edges: ::std::slice::IterMut<'a, Edge<E, Ix>>,
}
-impl<'a, E, Ix> Iterator for EdgeWeightsMut<'a, E, Ix> where
+impl<'a, E, Ix> Iterator for EdgeWeightsMut<'a, E, Ix>
+where
Ix: IndexType,
{
type Item = &'a mut E;
@@ -1703,7 +1759,8 @@
/// Index the `Graph` by `NodeIndex` to access node weights.
///
/// **Panics** if the node doesn't exist.
-impl<N, E, Ty, Ix> Index<NodeIndex<Ix>> for Graph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> Index<NodeIndex<Ix>> for Graph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
@@ -1716,20 +1773,21 @@
/// Index the `Graph` by `NodeIndex` to access node weights.
///
/// **Panics** if the node doesn't exist.
-impl<N, E, Ty, Ix> IndexMut<NodeIndex<Ix>> for Graph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> IndexMut<NodeIndex<Ix>> for Graph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
fn index_mut(&mut self, index: NodeIndex<Ix>) -> &mut N {
&mut self.nodes[index.index()].weight
}
-
}
/// Index the `Graph` by `EdgeIndex` to access edge weights.
///
/// **Panics** if the edge doesn't exist.
-impl<N, E, Ty, Ix> Index<EdgeIndex<Ix>> for Graph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> Index<EdgeIndex<Ix>> for Graph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
@@ -1742,7 +1800,8 @@
/// Index the `Graph` by `EdgeIndex` to access edge weights.
///
/// **Panics** if the edge doesn't exist.
-impl<N, E, Ty, Ix> IndexMut<EdgeIndex<Ix>> for Graph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> IndexMut<EdgeIndex<Ix>> for Graph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
@@ -1753,14 +1812,17 @@
/// Create a new empty `Graph`.
impl<N, E, Ty, Ix> Default for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
- fn default() -> Self { Self::with_capacity(0, 0) }
+ fn default() -> Self {
+ Self::with_capacity(0, 0)
+ }
}
/// A `GraphIndex` is a node or edge index.
-pub trait GraphIndex : Copy {
+pub trait GraphIndex: Copy {
#[doc(hidden)]
fn index(&self) -> usize;
#[doc(hidden)]
@@ -1769,16 +1831,24 @@
impl<Ix: IndexType> GraphIndex for NodeIndex<Ix> {
#[inline]
- fn index(&self) -> usize { NodeIndex::index(*self) }
+ fn index(&self) -> usize {
+ NodeIndex::index(*self)
+ }
#[inline]
- fn is_node_index() -> bool { true }
+ fn is_node_index() -> bool {
+ true
+ }
}
impl<Ix: IndexType> GraphIndex for EdgeIndex<Ix> {
#[inline]
- fn index(&self) -> usize { EdgeIndex::index(*self) }
+ fn index(&self) -> usize {
+ EdgeIndex::index(*self)
+ }
#[inline]
- fn is_node_index() -> bool { false }
+ fn is_node_index() -> bool {
+ false
+ }
}
/// A “walker” object that can be used to step through the edge list of a node.
@@ -1822,7 +1892,8 @@
}
impl<Ix> Clone for WalkNeighbors<Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
fn clone(&self) -> Self {
WalkNeighbors {
@@ -1839,8 +1910,10 @@
/// where the `WalkNeighbors` value was created.
/// For an `Outgoing` walk, the target nodes,
/// for an `Incoming` walk, the source nodes of the edge.
- pub fn next<N, E, Ty: EdgeType>(&mut self, g: &Graph<N, E, Ty, Ix>)
- -> Option<(EdgeIndex<Ix>, NodeIndex<Ix>)> {
+ pub fn next<N, E, Ty: EdgeType>(
+ &mut self,
+ g: &Graph<N, E, Ty, Ix>,
+ ) -> Option<(EdgeIndex<Ix>, NodeIndex<Ix>)> {
// First any outgoing edges
match g.edges.get(self.next[0].index()) {
None => {}
@@ -1864,15 +1937,17 @@
None
}
- pub fn next_node<N, E, Ty: EdgeType>(&mut self, g: &Graph<N, E, Ty, Ix>)
- -> Option<NodeIndex<Ix>>
- {
+ pub fn next_node<N, E, Ty: EdgeType>(
+ &mut self,
+ g: &Graph<N, E, Ty, Ix>,
+ ) -> Option<NodeIndex<Ix>> {
self.next(g).map(|t| t.1)
}
- pub fn next_edge<N, E, Ty: EdgeType>(&mut self, g: &Graph<N, E, Ty, Ix>)
- -> Option<EdgeIndex<Ix>>
- {
+ pub fn next_edge<N, E, Ty: EdgeType>(
+ &mut self,
+ g: &Graph<N, E, Ty, Ix>,
+ ) -> Option<EdgeIndex<Ix>> {
self.next(g).map(|t| t.0)
}
}
@@ -1945,10 +2020,11 @@
}
}
-impl<'a, E, Ix: IndexType> Copy for EdgeReference<'a, E, Ix> { }
+impl<'a, E, Ix: IndexType> Copy for EdgeReference<'a, E, Ix> {}
impl<'a, E, Ix: IndexType> PartialEq for EdgeReference<'a, E, Ix>
- where E: PartialEq,
+where
+ E: PartialEq,
{
fn eq(&self, rhs: &Self) -> bool {
self.index == rhs.index && self.weight == rhs.weight
@@ -1956,14 +2032,15 @@
}
impl<'a, N, E, Ty, Ix> IntoNodeReferences for &'a Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeRef = (NodeIndex<Ix>, &'a N);
type NodeReferences = NodeReferences<'a, N, Ix>;
fn node_references(self) -> Self::NodeReferences {
NodeReferences {
- iter: self.nodes.iter().enumerate()
+ iter: self.nodes.iter().enumerate(),
}
}
}
@@ -1974,14 +2051,15 @@
}
impl<'a, N, Ix> Iterator for NodeReferences<'a, N, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
type Item = (NodeIndex<Ix>, &'a N);
fn next(&mut self) -> Option<Self::Item> {
- self.iter.next().map(|(i, node)|
- (node_index(i), &node.weight)
- )
+ self.iter
+ .next()
+ .map(|(i, node)| (node_index(i), &node.weight))
}
fn size_hint(&self) -> (usize, Option<usize>) {
@@ -1990,61 +2068,70 @@
}
impl<'a, N, Ix> DoubleEndedIterator for NodeReferences<'a, N, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
fn next_back(&mut self) -> Option<Self::Item> {
- self.iter.next_back().map(|(i, node)|
- (node_index(i), &node.weight)
- )
+ self.iter
+ .next_back()
+ .map(|(i, node)| (node_index(i), &node.weight))
}
}
-impl<'a, N, Ix> ExactSizeIterator for NodeReferences<'a, N, Ix>
- where Ix: IndexType
-{ }
+impl<'a, N, Ix> ExactSizeIterator for NodeReferences<'a, N, Ix> where Ix: IndexType {}
impl<'a, Ix, E> EdgeReference<'a, E, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
/// Access the edge’s weight.
///
/// **NOTE** that this method offers a longer lifetime
/// than the trait (unfortunately they don't match yet).
- pub fn weight(&self) -> &'a E { self.weight }
+ pub fn weight(&self) -> &'a E {
+ self.weight
+ }
}
impl<'a, Ix, E> EdgeRef for EdgeReference<'a, E, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
type NodeId = NodeIndex<Ix>;
type EdgeId = EdgeIndex<Ix>;
type Weight = E;
- fn source(&self) -> Self::NodeId { self.node[0] }
- fn target(&self) -> Self::NodeId { self.node[1] }
- fn weight(&self) -> &E { self.weight }
- fn id(&self) -> Self::EdgeId { self.index }
+ fn source(&self) -> Self::NodeId {
+ self.node[0]
+ }
+ fn target(&self) -> Self::NodeId {
+ self.node[1]
+ }
+ fn weight(&self) -> &E {
+ self.weight
+ }
+ fn id(&self) -> Self::EdgeId {
+ self.index
+ }
}
-
/// Iterator over all edges of a graph.
pub struct EdgeReferences<'a, E: 'a, Ix: IndexType = DefaultIx> {
iter: iter::Enumerate<slice::Iter<'a, Edge<E, Ix>>>,
}
impl<'a, E, Ix> Iterator for EdgeReferences<'a, E, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
type Item = EdgeReference<'a, E, Ix>;
fn next(&mut self) -> Option<Self::Item> {
- self.iter.next().map(|(i, edge)|
- EdgeReference {
- index: edge_index(i),
- node: edge.node,
- weight: &edge.weight,
- }
- )
+ self.iter.next().map(|(i, edge)| EdgeReference {
+ index: edge_index(i),
+ node: edge.node,
+ weight: &edge.weight,
+ })
}
fn size_hint(&self) -> (usize, Option<usize>) {
@@ -2053,26 +2140,23 @@
}
impl<'a, E, Ix> DoubleEndedIterator for EdgeReferences<'a, E, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
fn next_back(&mut self) -> Option<Self::Item> {
- self.iter.next_back().map(|(i, edge)|
- EdgeReference {
- index: edge_index(i),
- node: edge.node,
- weight: &edge.weight,
- }
- )
+ self.iter.next_back().map(|(i, edge)| EdgeReference {
+ index: edge_index(i),
+ node: edge.node,
+ weight: &edge.weight,
+ })
}
}
-impl<'a, E, Ix> ExactSizeIterator for EdgeReferences<'a, E, Ix>
- where Ix: IndexType
-{}
+impl<'a, E, Ix> ExactSizeIterator for EdgeReferences<'a, E, Ix> where Ix: IndexType {}
+mod frozen;
#[cfg(feature = "stable_graph")]
pub mod stable_graph;
-mod frozen;
/// `Frozen` is a graph wrapper.
///
diff --git a/src/graph_impl/serialization.rs b/src/graph_impl/serialization.rs
index 8c93c2e..30f258b 100644
--- a/src/graph_impl/serialization.rs
+++ b/src/graph_impl/serialization.rs
@@ -1,19 +1,18 @@
-
use serde::de::Error;
use std::marker::PhantomData;
use crate::prelude::*;
-use crate::EdgeType;
use crate::graph::Node;
-use crate::graph::{IndexType, Edge};
-use crate::serde_utils::MappedSequenceVisitor;
+use crate::graph::{Edge, IndexType};
use crate::serde_utils::CollectSeqWithLength;
-use crate::serde_utils::{IntoSerializable, FromDeserialized};
+use crate::serde_utils::MappedSequenceVisitor;
+use crate::serde_utils::{FromDeserialized, IntoSerializable};
+use crate::EdgeType;
-use super::{NodeIndex, EdgeIndex};
-use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use super::{EdgeIndex, NodeIndex};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
/// Serialization representation for Graph
/// Keep in sync with deserialization and StableGraph
@@ -28,7 +27,7 @@
/// }
///
/// The same format is used by both Graph and StableGraph.
-///
+///
/// For graph there are restrictions:
/// node_holes is always empty and edges are always Some
///
@@ -42,11 +41,11 @@
#[serde(rename = "Graph")]
#[serde(bound(serialize = "N: Serialize, E: Serialize, Ix: IndexType + Serialize"))]
pub struct SerGraph<'a, N: 'a, E: 'a, Ix: 'a + IndexType> {
- #[serde(serialize_with="ser_graph_nodes")]
+ #[serde(serialize_with = "ser_graph_nodes")]
nodes: &'a [Node<N, Ix>],
node_holes: &'a [NodeIndex<Ix>],
edge_property: EdgeProperty,
- #[serde(serialize_with="ser_graph_edges")]
+ #[serde(serialize_with = "ser_graph_edges")]
edges: &'a [Edge<E, Ix>],
}
@@ -54,62 +53,71 @@
// Keep in sync with serialization and StableGraph
#[derive(Deserialize)]
#[serde(rename = "Graph")]
-#[serde(bound(deserialize = "N: Deserialize<'de>, E: Deserialize<'de>, Ix: IndexType + Deserialize<'de>"))]
+#[serde(bound(
+ deserialize = "N: Deserialize<'de>, E: Deserialize<'de>, Ix: IndexType + Deserialize<'de>"
+))]
pub struct DeserGraph<N, E, Ix> {
- #[serde(deserialize_with="deser_graph_nodes")]
+ #[serde(deserialize_with = "deser_graph_nodes")]
nodes: Vec<Node<N, Ix>>,
- #[serde(deserialize_with="deser_graph_node_holes")]
+ #[serde(deserialize_with = "deser_graph_node_holes")]
#[allow(unused)]
- #[serde(default="Vec::new")]
+ #[serde(default = "Vec::new")]
node_holes: Vec<NodeIndex<Ix>>,
edge_property: EdgeProperty,
- #[serde(deserialize_with="deser_graph_edges")]
+ #[serde(deserialize_with = "deser_graph_edges")]
edges: Vec<Edge<E, Ix>>,
}
-
impl<Ix> Serialize for NodeIndex<Ix>
- where Ix: IndexType + Serialize,
+where
+ Ix: IndexType + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer
+ where
+ S: Serializer,
{
self.0.serialize(serializer)
}
}
impl<'de, Ix> Deserialize<'de> for NodeIndex<Ix>
- where Ix: IndexType + Deserialize<'de>,
+where
+ Ix: IndexType + Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where D: Deserializer<'de>
+ where
+ D: Deserializer<'de>,
{
Ok(NodeIndex(Ix::deserialize(deserializer)?))
}
}
impl<Ix> Serialize for EdgeIndex<Ix>
- where Ix: IndexType + Serialize,
+where
+ Ix: IndexType + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer
+ where
+ S: Serializer,
{
self.0.serialize(serializer)
}
}
impl<'de, Ix> Deserialize<'de> for EdgeIndex<Ix>
- where Ix: IndexType + Deserialize<'de>,
+where
+ Ix: IndexType + Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where D: Deserializer<'de>
+ where
+ D: Deserializer<'de>,
{
Ok(EdgeIndex(Ix::deserialize(deserializer)?))
}
}
#[derive(Serialize, Deserialize)]
-#[serde(rename_all="lowercase")]
+#[serde(rename_all = "lowercase")]
#[derive(Debug)]
pub enum EdgeProperty {
Undirected,
@@ -125,7 +133,10 @@
}
}
-impl<Ty> From<PhantomData<Ty>> for EdgeProperty where Ty: EdgeType {
+impl<Ty> From<PhantomData<Ty>> for EdgeProperty
+where
+ Ty: EdgeType,
+{
fn from(_: PhantomData<Ty>) -> Self {
if Ty::is_directed() {
EdgeProperty::Directed
@@ -135,18 +146,22 @@
}
}
-
-impl<Ty> FromDeserialized for PhantomData<Ty> where Ty: EdgeType
+impl<Ty> FromDeserialized for PhantomData<Ty>
+where
+ Ty: EdgeType,
{
type Input = EdgeProperty;
fn from_deserialized<E2>(input: Self::Input) -> Result<Self, E2>
- where E2: Error
+ where
+ E2: Error,
{
if input.is_directed() != Ty::is_directed() {
- Err(E2::custom(format_args!("graph edge property mismatch, \
+ Err(E2::custom(format_args!(
+ "graph edge property mismatch, \
expected {:?}, found {:?}",
- EdgeProperty::from(PhantomData::<Ty>),
- input)))
+ EdgeProperty::from(PhantomData::<Ty>),
+ input
+ )))
} else {
Ok(PhantomData)
}
@@ -154,58 +169,64 @@
}
fn ser_graph_nodes<S, N, Ix>(nodes: &&[Node<N, Ix>], serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer,
- N: Serialize,
- Ix: Serialize + IndexType,
+where
+ S: Serializer,
+ N: Serialize,
+ Ix: Serialize + IndexType,
{
- serializer.collect_seq_exact(
- nodes.iter()
- .map(|node| &node.weight))
+ serializer.collect_seq_exact(nodes.iter().map(|node| &node.weight))
}
fn ser_graph_edges<S, E, Ix>(edges: &&[Edge<E, Ix>], serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer,
- E: Serialize,
- Ix: Serialize + IndexType,
+where
+ S: Serializer,
+ E: Serialize,
+ Ix: Serialize + IndexType,
{
serializer.collect_seq_exact(
- edges.iter()
- .map(|edge| Some((
- edge.source(),
- edge.target(),
- &edge.weight,
- ))))
+ edges
+ .iter()
+ .map(|edge| Some((edge.source(), edge.target(), &edge.weight))),
+ )
}
-
fn deser_graph_nodes<'de, D, N, Ix>(deserializer: D) -> Result<Vec<Node<N, Ix>>, D::Error>
- where D: Deserializer<'de>,
- N: Deserialize<'de>,
- Ix: IndexType + Deserialize<'de>,
+where
+ D: Deserializer<'de>,
+ N: Deserialize<'de>,
+ Ix: IndexType + Deserialize<'de>,
{
- deserializer.deserialize_seq(MappedSequenceVisitor::new(|n|
+ deserializer.deserialize_seq(MappedSequenceVisitor::new(|n| {
Ok(Node {
weight: n,
next: [EdgeIndex::end(); 2],
})
- ))
-}
-
-fn deser_graph_node_holes<'de, D, Ix>(deserializer: D) -> Result<Vec<NodeIndex<Ix>>, D::Error>
- where D: Deserializer<'de>,
- Ix: IndexType + Deserialize<'de>,
-{
- deserializer.deserialize_seq(MappedSequenceVisitor::<NodeIndex<Ix>, NodeIndex<Ix>, _>::new(|_| {
- Err("Graph can not have holes in the node set, found non-empty node_holes")
}))
}
-fn deser_graph_edges<'de, D, N, Ix>(deserializer: D) -> Result<Vec<Edge<N, Ix>>, D::Error>
- where D: Deserializer<'de>,
- N: Deserialize<'de>,
- Ix: IndexType + Deserialize<'de>,
+fn deser_graph_node_holes<'de, D, Ix>(deserializer: D) -> Result<Vec<NodeIndex<Ix>>, D::Error>
+where
+ D: Deserializer<'de>,
+ Ix: IndexType + Deserialize<'de>,
{
- deserializer.deserialize_seq(MappedSequenceVisitor::<Option<(NodeIndex<Ix>, NodeIndex<Ix>, N)>, _, _>::new(|x|
+ deserializer.deserialize_seq(
+ MappedSequenceVisitor::<NodeIndex<Ix>, NodeIndex<Ix>, _>::new(|_| {
+ Err("Graph can not have holes in the node set, found non-empty node_holes")
+ }),
+ )
+}
+
+fn deser_graph_edges<'de, D, N, Ix>(deserializer: D) -> Result<Vec<Edge<N, Ix>>, D::Error>
+where
+ D: Deserializer<'de>,
+ N: Deserialize<'de>,
+ Ix: IndexType + Deserialize<'de>,
+{
+ deserializer.deserialize_seq(MappedSequenceVisitor::<
+ Option<(NodeIndex<Ix>, NodeIndex<Ix>, N)>,
+ _,
+ _,
+ >::new(|x| {
if let Some((i, j, w)) = x {
Ok(Edge {
weight: w,
@@ -215,12 +236,13 @@
} else {
Err("Graph can not have holes in the edge set, found None, expected edge")
}
- ))
+ }))
}
impl<'a, N, E, Ty, Ix> IntoSerializable for &'a Graph<N, E, Ty, Ix>
- where Ix: IndexType,
- Ty: EdgeType,
+where
+ Ix: IndexType,
+ Ty: EdgeType,
{
type Output = SerGraph<'a, N, E, Ix>;
fn into_serializable(self) -> Self::Output {
@@ -235,39 +257,53 @@
/// Requires crate feature `"serde-1"`
impl<N, E, Ty, Ix> Serialize for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType + Serialize,
- N: Serialize,
- E: Serialize,
+where
+ Ty: EdgeType,
+ Ix: IndexType + Serialize,
+ N: Serialize,
+ E: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer
+ where
+ S: Serializer,
{
self.into_serializable().serialize(serializer)
}
}
-
-pub fn invalid_node_err<E>(node_index: usize, len: usize) -> E where E: Error {
- E::custom(format_args!("invalid value: node index `{}` does not exist in graph \
+pub fn invalid_node_err<E>(node_index: usize, len: usize) -> E
+where
+ E: Error,
+{
+ E::custom(format_args!(
+ "invalid value: node index `{}` does not exist in graph \
with node bound {}",
- node_index, len))
+ node_index, len
+ ))
}
pub fn invalid_length_err<Ix, E>(node_or_edge: &str, len: usize) -> E
- where E: Error, Ix: IndexType
+where
+ E: Error,
+ Ix: IndexType,
{
- E::custom(format_args!("invalid size: graph {} count {} exceeds index type maximum {}",
- node_or_edge, len, <Ix as IndexType>::max().index()))
+ E::custom(format_args!(
+ "invalid size: graph {} count {} exceeds index type maximum {}",
+ node_or_edge,
+ len,
+ <Ix as IndexType>::max().index()
+ ))
}
impl<'a, N, E, Ty, Ix> FromDeserialized for Graph<N, E, Ty, Ix>
- where Ix: IndexType,
- Ty: EdgeType,
+where
+ Ix: IndexType,
+ Ty: EdgeType,
{
type Input = DeserGraph<N, E, Ix>;
fn from_deserialized<E2>(input: Self::Input) -> Result<Self, E2>
- where E2: Error
+ where
+ E2: Error,
{
let ty = PhantomData::<Ty>::from_deserialized(input.edge_property)?;
let nodes = input.nodes;
@@ -286,23 +322,24 @@
ty: ty,
};
let nc = gr.node_count();
- gr.link_edges().map_err(|i| invalid_node_err(i.index(), nc))?;
+ gr.link_edges()
+ .map_err(|i| invalid_node_err(i.index(), nc))?;
Ok(gr)
}
}
-
/// Requires crate feature `"serde-1"`
impl<'de, N, E, Ty, Ix> Deserialize<'de> for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType + Deserialize<'de>,
- N: Deserialize<'de>,
- E: Deserialize<'de>,
+where
+ Ty: EdgeType,
+ Ix: IndexType + Deserialize<'de>,
+ N: Deserialize<'de>,
+ E: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where D: Deserializer<'de>
+ where
+ D: Deserializer<'de>,
{
Self::from_deserialized(DeserGraph::deserialize(deserializer)?)
}
}
-
diff --git a/src/graph_impl/stable_graph/mod.rs b/src/graph_impl/stable_graph/mod.rs
index a0bae5b..7c98681 100644
--- a/src/graph_impl/stable_graph/mod.rs
+++ b/src/graph_impl/stable_graph/mod.rs
@@ -12,51 +12,21 @@
use std::ops::{Index, IndexMut};
use std::slice;
-use crate::{
- Graph,
- EdgeType,
- Directed,
- Undirected,
- Direction,
- Incoming,
- Outgoing,
-};
+use crate::{Directed, Direction, EdgeType, Graph, Incoming, Outgoing, Undirected};
-use crate::iter_format::{
- IterFormatExt,
- NoPretty,
- DebugMap,
-};
+use crate::iter_format::{DebugMap, IterFormatExt, NoPretty};
use crate::iter_utils::IterUtilsExt;
-use super::{
- Edge,
- index_twice,
- Node,
- DIRECTIONS,
- Pair,
- Frozen,
+use super::{index_twice, Edge, Frozen, Node, Pair, DIRECTIONS};
+use crate::visit::{
+ EdgeRef, IntoEdgeReferences, IntoEdges, IntoEdgesDirected, IntoNodeReferences, NodeIndexable,
};
use crate::IntoWeightedEdge;
-use crate::visit::{
- EdgeRef,
- IntoNodeReferences,
- IntoEdges,
- IntoEdgesDirected,
- IntoEdgeReferences,
- NodeIndexable,
-};
// reexport those things that are shared with Graph
#[doc(no_inline)]
pub use crate::graph::{
- NodeIndex,
- EdgeIndex,
- GraphIndex,
- IndexType,
- DefaultIx,
- node_index,
- edge_index,
+ edge_index, node_index, DefaultIx, EdgeIndex, GraphIndex, IndexType, NodeIndex,
};
use crate::util::enumerate;
@@ -100,8 +70,7 @@
/// 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.*
-pub struct StableGraph<N, E, Ty = Directed, Ix = DefaultIx>
-{
+pub struct StableGraph<N, E, Ty = Directed, Ix = DefaultIx> {
g: Graph<Option<N>, Option<E>, Ty, Ix>,
node_count: usize,
edge_count: usize,
@@ -130,41 +99,60 @@
pub type StableUnGraph<N, E, Ix = DefaultIx> = StableGraph<N, E, Undirected, Ix>;
impl<N, E, Ty, Ix> fmt::Debug for StableGraph<N, E, Ty, Ix>
- where N: fmt::Debug,
- E: fmt::Debug,
- Ty: EdgeType,
- Ix: IndexType,
+where
+ N: fmt::Debug,
+ E: fmt::Debug,
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let etype = if self.is_directed() { "Directed" } else { "Undirected" };
+ let etype = if self.is_directed() {
+ "Directed"
+ } else {
+ "Undirected"
+ };
let mut fmt_struct = f.debug_struct("StableGraph");
fmt_struct.field("Ty", &etype);
fmt_struct.field("node_count", &self.node_count);
fmt_struct.field("edge_count", &self.edge_count);
if self.g.edges.iter().any(|e| e.weight.is_some()) {
- fmt_struct.field("edges", &self.g.edges.iter()
- .filter(|e| e.weight.is_some())
- .map(|e| NoPretty((e.source().index(), e.target().index())))
- .format(", "));
+ fmt_struct.field(
+ "edges",
+ &self
+ .g
+ .edges
+ .iter()
+ .filter(|e| e.weight.is_some())
+ .map(|e| NoPretty((e.source().index(), e.target().index())))
+ .format(", "),
+ );
}
// skip weights if they are ZST!
if size_of::<N>() != 0 {
- fmt_struct.field("node weights",
- &DebugMap(||
- self.g.nodes.iter()
- .map(|n| n.weight.as_ref())
- .enumerate()
- .filter_map(|(i, wo)| wo.map(move |w| (i, w)))
- ));
+ fmt_struct.field(
+ "node weights",
+ &DebugMap(|| {
+ self.g
+ .nodes
+ .iter()
+ .map(|n| n.weight.as_ref())
+ .enumerate()
+ .filter_map(|(i, wo)| wo.map(move |w| (i, w)))
+ }),
+ );
}
if size_of::<E>() != 0 {
- fmt_struct.field("edge weights",
- &DebugMap(||
- self.g.edges.iter()
- .map(|n| n.weight.as_ref())
- .enumerate()
- .filter_map(|(i, wo)| wo.map(move |w| (i, w)))
- ));
+ fmt_struct.field(
+ "edge weights",
+ &DebugMap(|| {
+ self.g
+ .edges
+ .iter()
+ .map(|n| n.weight.as_ref())
+ .enumerate()
+ .filter_map(|(i, wo)| wo.map(move |w| (i, w)))
+ }),
+ );
}
fmt_struct.field("free_node", &self.free_node);
fmt_struct.field("free_edge", &self.free_edge);
@@ -172,7 +160,6 @@
}
}
-
impl<N, E> StableGraph<N, E, Directed> {
/// Create a new `StableGraph` with directed edges.
///
@@ -185,8 +172,9 @@
}
impl<N, E, Ty, Ix> StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
/// Create a new `StableGraph` with estimated capacity.
pub fn with_capacity(nodes: usize, edges: usize) -> Self {
@@ -298,7 +286,7 @@
loop {
let next = self.g.nodes[a.index()].next[k];
if next == EdgeIndex::end() {
- break
+ break;
}
let ret = self.remove_edge(next);
debug_assert!(ret.is_some());
@@ -322,8 +310,10 @@
// Return the Node if it is not vacant (non-None weight)
fn get_node(&self, a: NodeIndex<Ix>) -> Option<&Node<Option<N>, Ix>> {
- self.g.nodes.get(a.index())
- .and_then(|node| node.weight.as_ref().map(move |_| node))
+ self.g
+ .nodes
+ .get(a.index())
+ .and_then(|node| node.weight.as_ref().map(move |_| node))
}
/// Add an edge from `a` to `b` to the graph, with its associated
@@ -338,9 +328,7 @@
/// its index type.
///
/// **Note:** `StableGraph` allows adding parallel (“duplicate”) edges.
- pub fn add_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E)
- -> EdgeIndex<Ix>
- {
+ pub fn add_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E) -> EdgeIndex<Ix> {
let edge_idx;
let mut new_edge = None::<Edge<_, _>>;
{
@@ -391,7 +379,10 @@
}
};
if let Some(i) = wrong_index {
- panic!("StableGraph::add_edge: node index {} is not a node in the graph", i);
+ panic!(
+ "StableGraph::add_edge: node index {} is not a node in the graph",
+ i
+ );
}
self.edge_count += 1;
}
@@ -424,9 +415,7 @@
/// connected to `a` (and `b`, if the graph edges are undirected).
///
/// **Panics** if any of the nodes don't exist.
- pub fn update_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E)
- -> EdgeIndex<Ix>
- {
+ pub fn update_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>, weight: E) -> EdgeIndex<Ix> {
if let Some(ix) = self.find_edge(a, b) {
self[ix] = weight;
return ix;
@@ -488,7 +477,7 @@
/// Return an iterator over the node indices of the graph
pub fn node_indices(&self) -> NodeIndices<N, Ix> {
NodeIndices {
- iter: enumerate(self.raw_nodes())
+ iter: enumerate(self.raw_nodes()),
}
}
@@ -513,9 +502,7 @@
}
/// Access the source and target nodes for `e`.
- pub fn edge_endpoints(&self, e: EdgeIndex<Ix>)
- -> Option<(NodeIndex<Ix>, NodeIndex<Ix>)>
- {
+ pub fn edge_endpoints(&self, e: EdgeIndex<Ix>) -> Option<(NodeIndex<Ix>, NodeIndex<Ix>)> {
match self.g.edges.get(e.index()) {
Some(ed) if ed.weight.is_some() => Some((ed.source(), ed.target())),
_otherwise => None,
@@ -525,7 +512,7 @@
/// Return an iterator over the node indices of the graph
pub fn edge_indices(&self) -> EdgeIndices<E, Ix> {
EdgeIndices {
- iter: enumerate(self.raw_edges())
+ iter: enumerate(self.raw_edges()),
}
}
@@ -541,14 +528,13 @@
///
/// Computes in **O(e')** time, where **e'** is the number of edges
/// connected to `a` (and `b`, if the graph edges are undirected).
- pub fn find_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> Option<EdgeIndex<Ix>>
- {
+ pub fn find_edge(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> Option<EdgeIndex<Ix>> {
if !self.is_directed() {
self.find_edge_undirected(a, b).map(|(ix, _)| ix)
} else {
match self.get_node(a) {
None => None,
- Some(node) => self.g.find_edge_directed_from_node(node, b)
+ Some(node) => self.g.find_edge_directed_from_node(node, b),
}
}
}
@@ -560,15 +546,17 @@
/// 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.
- pub fn find_edge_undirected(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> Option<(EdgeIndex<Ix>, Direction)>
- {
+ pub fn find_edge_undirected(
+ &self,
+ a: NodeIndex<Ix>,
+ b: NodeIndex<Ix>,
+ ) -> Option<(EdgeIndex<Ix>, Direction)> {
match self.get_node(a) {
None => None,
Some(node) => self.g.find_edge_undirected_from_node(node, b),
}
}
-
/// Return an iterator of all nodes with an edge starting from `a`.
///
/// - `Directed`: Outgoing edges from `a`.
@@ -600,9 +588,7 @@
/// not borrow from the graph.
///
/// [1]: struct.Neighbors.html#method.detach
- pub fn neighbors_directed(&self, a: NodeIndex<Ix>, dir: Direction)
- -> Neighbors<E, Ix>
- {
+ pub fn neighbors_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Neighbors<E, Ix> {
let mut iter = self.neighbors_undirected(a);
if self.is_directed() {
let k = dir.index();
@@ -625,15 +611,14 @@
/// not borrow from the graph.
///
/// [1]: struct.Neighbors.html#method.detach
- pub fn neighbors_undirected(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix>
- {
+ pub fn neighbors_undirected(&self, a: NodeIndex<Ix>) -> Neighbors<E, Ix> {
Neighbors {
skip_start: a,
edges: &self.g.edges,
next: match self.get_node(a) {
None => [EdgeIndex::end(), EdgeIndex::end()],
Some(n) => n.next,
- }
+ },
}
}
@@ -659,8 +644,7 @@
///
/// Produces an empty iterator if the node `a` doesn't exist.<br>
/// Iterator element type is `EdgeReference<E, Ix>`.
- pub fn edges_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Edges<E, Ty, Ix>
- {
+ pub fn edges_directed(&self, a: NodeIndex<Ix>, dir: Direction) -> Edges<E, Ty, Ix> {
Edges {
skip_start: a,
edges: &self.g.edges,
@@ -684,30 +668,40 @@
/// just the nodes without edges.
///
/// The whole iteration computes in **O(|V|)** time.
- pub fn externals(&self, dir: Direction) -> Externals<N, Ty, Ix>
- {
- Externals { iter: self.raw_nodes().iter().enumerate(), dir, ty: PhantomData }
+ pub fn externals(&self, dir: Direction) -> Externals<N, Ty, Ix> {
+ Externals {
+ iter: self.raw_nodes().iter().enumerate(),
+ dir,
+ ty: PhantomData,
+ }
}
/// 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.
- pub fn index_twice_mut<T, U>(&mut self, i: T, j: U)
- -> (&mut <Self as Index<T>>::Output,
- &mut <Self as Index<U>>::Output)
- where Self: IndexMut<T> + IndexMut<U>,
- T: GraphIndex,
- U: GraphIndex,
+ pub fn index_twice_mut<T, U>(
+ &mut self,
+ i: T,
+ j: U,
+ ) -> (
+ &mut <Self as Index<T>>::Output,
+ &mut <Self as Index<U>>::Output,
+ )
+ where
+ Self: IndexMut<T> + IndexMut<U>,
+ T: GraphIndex,
+ U: GraphIndex,
{
- assert!(T::is_node_index() != U::is_node_index() ||
- i.index() != j.index());
+ assert!(T::is_node_index() != U::is_node_index() || i.index() != j.index());
// Allow two mutable indexes here -- they are nonoverlapping
unsafe {
let self_mut = self as *mut _;
- (<Self as IndexMut<T>>::index_mut(&mut *self_mut, i),
- <Self as IndexMut<U>>::index_mut(&mut *self_mut, j))
+ (
+ <Self as IndexMut<T>>::index_mut(&mut *self_mut, i),
+ <Self as IndexMut<U>>::index_mut(&mut *self_mut, j),
+ )
}
}
@@ -726,7 +720,10 @@
/// 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.
- pub fn retain_nodes<F>(&mut self, mut visit: F) where F: FnMut(Frozen<Self>, NodeIndex<Ix>) -> bool {
+ pub fn retain_nodes<F>(&mut self, mut visit: F)
+ where
+ F: FnMut(Frozen<Self>, NodeIndex<Ix>) -> bool,
+ {
for i in 0..self.node_bound() {
let ix = node_index(i);
if self.contains_node(ix) && !visit(Frozen(self), ix) {
@@ -749,7 +746,8 @@
/// Computes in **O(e'')** time, **e'** is the number of affected edges,
/// including the calls to `.remove_edge()` for each removed edge.
pub fn retain_edges<F>(&mut self, mut visit: F)
- where F: FnMut(Frozen<Self>, EdgeIndex<Ix>) -> bool
+ where
+ F: FnMut(Frozen<Self>, EdgeIndex<Ix>) -> bool,
{
for i in 0..self.edge_bound() {
let ix = edge_index(i);
@@ -778,10 +776,11 @@
/// ]);
/// ```
pub fn from_edges<I>(iterable: I) -> Self
- where I: IntoIterator,
- I::Item: IntoWeightedEdge<E>,
- <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
- N: Default,
+ where
+ I: IntoIterator,
+ I::Item: IntoWeightedEdge<E>,
+ <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
+ N: Default,
{
let mut g = Self::with_capacity(0, 0);
g.extend_with_edges(iterable);
@@ -793,14 +792,19 @@
///
/// The resulting graph has the same structure and the same
/// graph indices as `self`.
- pub fn map<'a, F, G, N2, E2>(&'a self, mut node_map: F, mut edge_map: G)
- -> StableGraph<N2, E2, Ty, Ix>
- where F: FnMut(NodeIndex<Ix>, &'a N) -> N2,
- G: FnMut(EdgeIndex<Ix>, &'a E) -> E2,
+ pub fn map<'a, F, G, N2, E2>(
+ &'a self,
+ mut node_map: F,
+ mut edge_map: G,
+ ) -> StableGraph<N2, E2, Ty, Ix>
+ where
+ F: FnMut(NodeIndex<Ix>, &'a N) -> N2,
+ G: FnMut(EdgeIndex<Ix>, &'a E) -> E2,
{
let g = self.g.map(
move |i, w| w.as_ref().map(|w| node_map(i, w)),
- move |i, w| w.as_ref().map(|w| edge_map(i, w)));
+ move |i, w| w.as_ref().map(|w| edge_map(i, w)),
+ );
StableGraph {
g,
node_count: self.node_count,
@@ -821,10 +825,14 @@
/// 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.
- pub fn filter_map<'a, F, G, N2, E2>(&'a self, mut node_map: F, mut 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>,
+ pub fn filter_map<'a, F, G, N2, E2>(
+ &'a self,
+ mut node_map: F,
+ mut 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>,
{
let node_bound = self.node_bound();
let edge_bound = self.edge_bound();
@@ -837,7 +845,9 @@
// the stable graph keeps the node map itself
for (i, node) in enumerate(self.raw_nodes()) {
- if i >= node_bound { break; }
+ if i >= node_bound {
+ break;
+ }
if let Some(node_weight) = node.weight.as_ref() {
if let Some(new_weight) = node_map(NodeIndex::new(i), node_weight) {
result_g.add_node(new_weight);
@@ -847,7 +857,9 @@
result_g.add_vacant_node(&mut free_node);
}
for (i, edge) in enumerate(self.raw_edges()) {
- if i >= edge_bound { break; }
+ if i >= edge_bound {
+ break;
+ }
let source = edge.source();
let target = edge.target();
if let Some(edge_weight) = edge.weight.as_ref() {
@@ -874,10 +886,11 @@
///
/// Nodes are inserted automatically to match the edges.
pub fn extend_with_edges<I>(&mut self, iterable: I)
- where I: IntoIterator,
- I::Item: IntoWeightedEdge<E>,
- <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
- N: Default,
+ where
+ I: IntoIterator,
+ I::Item: IntoWeightedEdge<E>,
+ <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
+ N: Default,
{
let iter = iterable.into_iter();
@@ -959,7 +972,7 @@
}
#[cfg(not(debug_assertions))]
- fn check_free_lists(&self) { }
+ fn check_free_lists(&self) {}
#[cfg(debug_assertions)]
// internal method to debug check the free lists (linked lists)
fn check_free_lists(&self) {
@@ -972,8 +985,11 @@
free_node_len += 1;
continue;
}
- debug_assert!(false, "Corrupt free list: pointing to existing {:?}",
- free_node.index());
+ debug_assert!(
+ false,
+ "Corrupt free list: pointing to existing {:?}",
+ free_node.index()
+ );
}
debug_assert!(false, "Corrupt free list: missing {:?}", free_node.index());
}
@@ -988,8 +1004,11 @@
free_edge_len += 1;
continue;
}
- debug_assert!(false, "Corrupt free list: pointing to existing {:?}",
- free_node.index());
+ debug_assert!(
+ false,
+ "Corrupt free list: pointing to existing {:?}",
+ free_node.index()
+ );
}
debug_assert!(false, "Corrupt free list: missing {:?}", free_edge.index());
}
@@ -999,7 +1018,9 @@
/// The resulting cloned graph has the same graph indices as `self`.
impl<N, E, Ty, Ix: IndexType> Clone for StableGraph<N, E, Ty, Ix>
- where N: Clone, E: Clone,
+where
+ N: Clone,
+ E: Clone,
{
fn clone(&self) -> Self {
StableGraph {
@@ -1023,7 +1044,8 @@
/// Index the `StableGraph` by `NodeIndex` to access node weights.
///
/// **Panics** if the node doesn't exist.
-impl<N, E, Ty, Ix> Index<NodeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> Index<NodeIndex<Ix>> for StableGraph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
@@ -1036,20 +1058,21 @@
/// Index the `StableGraph` by `NodeIndex` to access node weights.
///
/// **Panics** if the node doesn't exist.
-impl<N, E, Ty, Ix> IndexMut<NodeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> IndexMut<NodeIndex<Ix>> for StableGraph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
fn index_mut(&mut self, index: NodeIndex<Ix>) -> &mut N {
self.node_weight_mut(index).unwrap()
}
-
}
/// Index the `StableGraph` by `EdgeIndex` to access edge weights.
///
/// **Panics** if the edge doesn't exist.
-impl<N, E, Ty, Ix> Index<EdgeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> Index<EdgeIndex<Ix>> for StableGraph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
@@ -1062,7 +1085,8 @@
/// Index the `StableGraph` by `EdgeIndex` to access edge weights.
///
/// **Panics** if the edge doesn't exist.
-impl<N, E, Ty, Ix> IndexMut<EdgeIndex<Ix>> for StableGraph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> IndexMut<EdgeIndex<Ix>> for StableGraph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
@@ -1073,10 +1097,13 @@
/// Create a new empty `StableGraph`.
impl<N, E, Ty, Ix> Default for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
- fn default() -> Self { Self::with_capacity(0, 0) }
+ fn default() -> Self {
+ Self::with_capacity(0, 0)
+ }
}
/// Convert a `Graph` into a `StableGraph`
@@ -1086,8 +1113,9 @@
/// The resulting graph has the same node and edge indices as
/// the original graph.
impl<N, E, Ty, Ix> From<Graph<N, E, Ty, Ix>> for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn from(g: Graph<N, E, Ty, Ix>) -> Self {
let nodes = g.nodes.into_iter().map(|e| Node {
@@ -1102,7 +1130,11 @@
StableGraph {
node_count: nodes.len(),
edge_count: edges.len(),
- g: Graph { edges: edges.collect(), nodes: nodes.collect(), ty: g.ty },
+ g: Graph {
+ edges: edges.collect(),
+ nodes: nodes.collect(),
+ ty: g.ty,
+ },
free_node: NodeIndex::end(),
free_edge: EdgeIndex::end(),
}
@@ -1120,8 +1152,9 @@
/// equal to node count, and the same for edges), would the resulting graph have
/// the same node and edge indices as the input.
impl<N, E, Ty, Ix> From<StableGraph<N, E, Ty, Ix>> for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn from(graph: StableGraph<N, E, Ty, Ix>) -> Self {
let mut result_g = Graph::with_capacity(graph.node_count(), graph.edge_count());
@@ -1149,14 +1182,15 @@
}
impl<'a, N, E, Ty, Ix> IntoNodeReferences for &'a StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeRef = (NodeIndex<Ix>, &'a N);
type NodeReferences = NodeReferences<'a, N, Ix>;
fn node_references(self) -> Self::NodeReferences {
NodeReferences {
- iter: enumerate(self.raw_nodes())
+ iter: enumerate(self.raw_nodes()),
}
}
}
@@ -1167,14 +1201,14 @@
}
impl<'a, N, Ix> Iterator for NodeReferences<'a, N, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
type Item = (NodeIndex<Ix>, &'a N);
fn next(&mut self) -> Option<Self::Item> {
- self.iter.ex_find_map(|(i, node)| {
- node.weight.as_ref().map(move |w| (node_index(i), w))
- })
+ self.iter
+ .ex_find_map(|(i, node)| node.weight.as_ref().map(move |w| (node_index(i), w)))
}
fn size_hint(&self) -> (usize, Option<usize>) {
@@ -1184,12 +1218,12 @@
}
impl<'a, N, Ix> DoubleEndedIterator for NodeReferences<'a, N, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
fn next_back(&mut self) -> Option<Self::Item> {
- self.iter.ex_rfind_map(|(i, node)| {
- node.weight.as_ref().map(move |w| (node_index(i), w))
- })
+ self.iter
+ .ex_rfind_map(|(i, node)| node.weight.as_ref().map(move |w| (node_index(i), w)))
}
}
@@ -1207,10 +1241,11 @@
}
}
-impl<'a, E, Ix: IndexType> Copy for EdgeReference<'a, E, Ix> { }
+impl<'a, E, Ix: IndexType> Copy for EdgeReference<'a, E, Ix> {}
impl<'a, E, Ix: IndexType> PartialEq for EdgeReference<'a, E, Ix>
- where E: PartialEq,
+where
+ E: PartialEq,
{
fn eq(&self, rhs: &Self) -> bool {
self.index == rhs.index && self.weight == rhs.weight
@@ -1218,31 +1253,44 @@
}
impl<'a, Ix, E> EdgeReference<'a, E, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
/// Access the edge’s weight.
///
/// **NOTE** that this method offers a longer lifetime
/// than the trait (unfortunately they don't match yet).
- pub fn weight(&self) -> &'a E { self.weight }
+ pub fn weight(&self) -> &'a E {
+ self.weight
+ }
}
impl<'a, Ix, E> EdgeRef for EdgeReference<'a, E, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
type NodeId = NodeIndex<Ix>;
type EdgeId = EdgeIndex<Ix>;
type Weight = E;
- fn source(&self) -> Self::NodeId { self.node[0] }
- fn target(&self) -> Self::NodeId { self.node[1] }
- fn weight(&self) -> &E { self.weight }
- fn id(&self) -> Self::EdgeId { self.index }
+ fn source(&self) -> Self::NodeId {
+ self.node[0]
+ }
+ fn target(&self) -> Self::NodeId {
+ self.node[1]
+ }
+ fn weight(&self) -> &E {
+ self.weight
+ }
+ fn id(&self) -> Self::EdgeId {
+ self.index
+ }
}
impl<'a, N, E, Ty, Ix> IntoEdges for &'a StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Edges = Edges<'a, E, Ty, Ix>;
fn edges(self, a: Self::NodeId) -> Self::Edges {
@@ -1251,8 +1299,9 @@
}
impl<'a, N, E, Ty, Ix> IntoEdgesDirected for &'a StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgesDirected = Edges<'a, E, Ty, Ix>;
fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::EdgesDirected {
@@ -1262,8 +1311,9 @@
/// Iterator over the edges of from or to a node
pub struct Edges<'a, E: 'a, Ty, Ix: 'a = DefaultIx>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
/// starting node to skip over
skip_start: NodeIndex<Ix>,
@@ -1279,8 +1329,9 @@
}
impl<'a, E, Ty, Ix> Iterator for Edges<'a, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Item = EdgeReference<'a, E, Ix>;
@@ -1302,7 +1353,12 @@
if iterate_over.unwrap_or(Outgoing) == Outgoing {
let i = self.next[0].index();
- if let Some(Edge { node, weight: Some(weight), next }) = self.edges.get(i) {
+ if let Some(Edge {
+ node,
+ weight: Some(weight),
+ next,
+ }) = self.edges.get(i)
+ {
self.next[0] = next[0];
return Some(EdgeReference {
index: edge_index(i),
@@ -1335,7 +1391,7 @@
*node
},
weight: weight.as_ref().unwrap(),
- })
+ });
}
}
@@ -1349,8 +1405,9 @@
}
impl<'a, N: 'a, E: 'a, Ty, Ix> IntoEdgeReferences for &'a StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgeRef = EdgeReference<'a, E, Ix>;
type EdgeReferences = EdgeReferences<'a, E, Ix>;
@@ -1360,10 +1417,9 @@
/// Iterator element type is `EdgeReference<E, Ix>`.
fn edge_references(self) -> Self::EdgeReferences {
EdgeReferences {
- iter: self.g.edges.iter().enumerate()
+ iter: self.g.edges.iter().enumerate(),
}
}
-
}
/// Iterator over all edges of a graph.
@@ -1372,34 +1428,34 @@
}
impl<'a, E, Ix> Iterator for EdgeReferences<'a, E, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
type Item = EdgeReference<'a, E, Ix>;
fn next(&mut self) -> Option<Self::Item> {
- self.iter.ex_find_map(|(i, edge)|
- edge.weight.as_ref().map(move |weight| {
- EdgeReference {
- index: edge_index(i),
- node: edge.node,
- weight,
- }
- }))
+ self.iter.ex_find_map(|(i, edge)| {
+ edge.weight.as_ref().map(move |weight| EdgeReference {
+ index: edge_index(i),
+ node: edge.node,
+ weight,
+ })
+ })
}
}
impl<'a, E, Ix> DoubleEndedIterator for EdgeReferences<'a, E, Ix>
- where Ix: IndexType
+where
+ Ix: IndexType,
{
fn next_back(&mut self) -> Option<Self::Item> {
- self.iter.ex_rfind_map(|(i, edge)|
- edge.weight.as_ref().map(move |weight| {
- EdgeReference {
- index: edge_index(i),
- node: edge.node,
- weight,
- }
- }))
+ self.iter.ex_rfind_map(|(i, edge)| {
+ edge.weight.as_ref().map(move |weight| EdgeReference {
+ index: edge_index(i),
+ node: edge.node,
+ weight,
+ })
+ })
}
}
@@ -1410,27 +1466,27 @@
ty: PhantomData<Ty>,
}
-impl<'a, N: 'a, Ty, Ix> Iterator for Externals<'a, N, Ty, Ix> where
+impl<'a, N: 'a, Ty, Ix> Iterator for Externals<'a, N, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
type Item = NodeIndex<Ix>;
- fn next(&mut self) -> Option<NodeIndex<Ix>>
- {
+ fn next(&mut self) -> Option<NodeIndex<Ix>> {
let k = self.dir.index();
loop {
match self.iter.next() {
None => return None,
Some((index, node)) => {
- if node.weight.is_some() &&
- node.next[k] == EdgeIndex::end() &&
- (Ty::is_directed() ||
- node.next[1-k] == EdgeIndex::end()) {
- return Some(NodeIndex::new(index))
+ if node.weight.is_some()
+ && node.next[k] == EdgeIndex::end()
+ && (Ty::is_directed() || node.next[1 - k] == EdgeIndex::end())
+ {
+ return Some(NodeIndex::new(index));
} else {
- continue
+ continue;
}
- },
+ }
}
}
}
@@ -1439,8 +1495,7 @@
/// Iterator over the neighbors of a node.
///
/// Iterator element type is `NodeIndex`.
-pub struct Neighbors<'a, E: 'a, Ix: 'a = DefaultIx>
-{
+pub struct Neighbors<'a, E: 'a, Ix: 'a = DefaultIx> {
/// starting node to skip over
skip_start: NodeIndex<Ix>,
edges: &'a [Edge<Option<E>, Ix>],
@@ -1448,7 +1503,8 @@
}
impl<'a, E, Ix> Neighbors<'a, E, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
/// Return a “walker” object that can be used to step through the
/// neighbors and edges from the origin node.
@@ -1459,13 +1515,14 @@
WalkNeighbors {
inner: super::WalkNeighbors {
skip_start: self.skip_start,
- next: self.next
+ next: self.next,
},
}
}
}
-impl<'a, E, Ix> Iterator for Neighbors<'a, E, Ix> where
+impl<'a, E, Ix> Iterator for Neighbors<'a, E, Ix>
+where
Ix: IndexType,
{
type Item = NodeIndex<Ix>;
@@ -1546,20 +1603,24 @@
/// where the `WalkNeighbors` value was created.
/// For an `Outgoing` walk, the target nodes,
/// for an `Incoming` walk, the source nodes of the edge.
- pub fn next<N, E, Ty: EdgeType>(&mut self, g: &StableGraph<N, E, Ty, Ix>)
- -> Option<(EdgeIndex<Ix>, NodeIndex<Ix>)> {
+ pub fn next<N, E, Ty: EdgeType>(
+ &mut self,
+ g: &StableGraph<N, E, Ty, Ix>,
+ ) -> Option<(EdgeIndex<Ix>, NodeIndex<Ix>)> {
self.inner.next(&g.g)
}
- pub fn next_node<N, E, Ty: EdgeType>(&mut self, g: &StableGraph<N, E, Ty, Ix>)
- -> Option<NodeIndex<Ix>>
- {
+ pub fn next_node<N, E, Ty: EdgeType>(
+ &mut self,
+ g: &StableGraph<N, E, Ty, Ix>,
+ ) -> Option<NodeIndex<Ix>> {
self.next(g).map(|t| t.1)
}
- pub fn next_edge<N, E, Ty: EdgeType>(&mut self, g: &StableGraph<N, E, Ty, Ix>)
- -> Option<EdgeIndex<Ix>>
- {
+ pub fn next_edge<N, E, Ty: EdgeType>(
+ &mut self,
+ g: &StableGraph<N, E, Ty, Ix>,
+ ) -> Option<EdgeIndex<Ix>> {
self.next(g).map(|t| t.0)
}
}
@@ -1576,7 +1637,9 @@
self.iter.ex_find_map(|(i, node)| {
if node.weight.is_some() {
Some(node_index(i))
- } else { None }
+ } else {
+ None
+ }
})
}
@@ -1591,23 +1654,28 @@
self.iter.ex_rfind_map(|(i, node)| {
if node.weight.is_some() {
Some(node_index(i))
- } else { None }
+ } else {
+ None
+ }
})
}
}
impl<N, E, Ty, Ix> NodeIndexable for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
/// Return an upper bound of the node indices in the graph
fn node_bound(&self) -> usize {
- self.node_indices()
- .next_back()
- .map_or(0, |i| i.index() + 1)
+ self.node_indices().next_back().map_or(0, |i| i.index() + 1)
}
- fn to_index(&self, ix: NodeIndex<Ix>) -> usize { ix.index() }
- fn from_index(&self, ix: usize) -> Self::NodeId { NodeIndex::new(ix) }
+ fn to_index(&self, ix: NodeIndex<Ix>) -> usize {
+ ix.index()
+ }
+ fn from_index(&self, ix: usize) -> Self::NodeId {
+ NodeIndex::new(ix)
+ }
}
/// Iterator over the edge indices of a graph.
@@ -1622,7 +1690,9 @@
self.iter.ex_find_map(|(i, node)| {
if node.weight.is_some() {
Some(edge_index(i))
- } else { None }
+ } else {
+ None
+ }
})
}
@@ -1637,12 +1707,13 @@
self.iter.ex_rfind_map(|(i, node)| {
if node.weight.is_some() {
Some(edge_index(i))
- } else { None }
+ } else {
+ None
+ }
})
}
}
-
#[test]
fn stable_graph() {
let mut gr = StableGraph::<_, _>::with_capacity(0, 0);
@@ -1718,7 +1789,7 @@
assert_eq!(gr.node_count(), 5);
assert_eq!(gr.edge_count(), 8);
- gr.retain_nodes(|frozen_gr, ix| {frozen_gr[ix] >= "c"});
+ gr.retain_nodes(|frozen_gr, ix| frozen_gr[ix] >= "c");
assert_eq!(gr.node_count(), 3);
assert_eq!(gr.edge_count(), 2);
diff --git a/src/graph_impl/stable_graph/serialization.rs b/src/graph_impl/stable_graph/serialization.rs
index da031c6..c24ca63 100644
--- a/src/graph_impl/stable_graph/serialization.rs
+++ b/src/graph_impl/stable_graph/serialization.rs
@@ -1,23 +1,21 @@
-
-
use serde::de::Error;
-use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::marker::PhantomData;
use crate::prelude::*;
-use crate::EdgeType;
use crate::graph::Node;
-use crate::graph::{IndexType, Edge};
+use crate::graph::{Edge, IndexType};
+use crate::serde_utils::CollectSeqWithLength;
+use crate::serde_utils::MappedSequenceVisitor;
+use crate::serde_utils::{FromDeserialized, IntoSerializable};
use crate::stable_graph::StableGraph;
use crate::util::rev;
-use crate::serde_utils::MappedSequenceVisitor;
-use crate::serde_utils::CollectSeqWithLength;
-use crate::serde_utils::{IntoSerializable, FromDeserialized};
use crate::visit::NodeIndexable;
+use crate::EdgeType;
-use super::super::serialization::{EdgeProperty, invalid_length_err, invalid_node_err};
+use super::super::serialization::{invalid_length_err, invalid_node_err, EdgeProperty};
// Serialization representation for StableGraph
// Keep in sync with deserialization and Graph
@@ -28,7 +26,7 @@
nodes: Somes<&'a [Node<Option<N>, Ix>]>,
node_holes: Holes<&'a [Node<Option<N>, Ix>]>,
edge_property: EdgeProperty,
- #[serde(serialize_with="ser_stable_graph_edges")]
+ #[serde(serialize_with = "ser_stable_graph_edges")]
edges: &'a [Edge<Option<E>, Ix>],
}
@@ -36,14 +34,16 @@
// Keep in sync with serialization and Graph
#[derive(Deserialize)]
#[serde(rename = "Graph")]
-#[serde(bound(deserialize = "N: Deserialize<'de>, E: Deserialize<'de>, Ix: IndexType + Deserialize<'de>"))]
+#[serde(bound(
+ deserialize = "N: Deserialize<'de>, E: Deserialize<'de>, Ix: IndexType + Deserialize<'de>"
+))]
pub struct DeserStableGraph<N, E, Ix> {
- #[serde(deserialize_with="deser_stable_graph_nodes")]
+ #[serde(deserialize_with = "deser_stable_graph_nodes")]
nodes: Vec<Node<Option<N>, Ix>>,
- #[serde(default="Vec::new")]
+ #[serde(default = "Vec::new")]
node_holes: Vec<NodeIndex<Ix>>,
edge_property: EdgeProperty,
- #[serde(deserialize_with="deser_stable_graph_edges")]
+ #[serde(deserialize_with = "deser_stable_graph_edges")]
edges: Vec<Edge<Option<E>, Ix>>,
}
@@ -51,13 +51,17 @@
struct Somes<T>(usize, T);
impl<'a, N, Ix> Serialize for Somes<&'a [Node<Option<N>, Ix>]>
- where N: Serialize,
+where
+ N: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer,
+ where
+ S: Serializer,
{
- serializer.collect_seq_with_length(self.0,
- self.1.iter().filter_map(|node| node.weight.as_ref()))
+ serializer.collect_seq_with_length(
+ self.0,
+ self.1.iter().filter_map(|node| node.weight.as_ref()),
+ )
}
}
@@ -65,55 +69,71 @@
struct Holes<T>(usize, T);
impl<'a, N, Ix> Serialize for Holes<&'a [Node<Option<N>, Ix>]>
- where Ix: Serialize + IndexType,
+where
+ Ix: Serialize + IndexType,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer,
+ where
+ S: Serializer,
{
- serializer.collect_seq_with_length(self.0,
- self.1.iter()
- .enumerate()
- .filter_map(|(i, node)| if node.weight.is_none() {
- Some(NodeIndex::<Ix>::new(i))
- } else {
- None
- }))
+ serializer.collect_seq_with_length(
+ self.0,
+ self.1.iter().enumerate().filter_map(|(i, node)| {
+ if node.weight.is_none() {
+ Some(NodeIndex::<Ix>::new(i))
+ } else {
+ None
+ }
+ }),
+ )
}
}
-fn ser_stable_graph_edges<S, E, Ix>(edges: &&[Edge<Option<E>, Ix>], serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer,
- E: Serialize,
- Ix: Serialize + IndexType,
+fn ser_stable_graph_edges<S, E, Ix>(
+ edges: &&[Edge<Option<E>, Ix>],
+ serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+ S: Serializer,
+ E: Serialize,
+ Ix: Serialize + IndexType,
{
- serializer.collect_seq_exact(
- edges.iter()
- .map(|edge| edge.weight.as_ref().map(|w| (
- edge.source(),
- edge.target(),
- w
- ))))
+ serializer.collect_seq_exact(edges.iter().map(|edge| {
+ edge.weight
+ .as_ref()
+ .map(|w| (edge.source(), edge.target(), w))
+ }))
}
-fn deser_stable_graph_nodes<'de, D, N, Ix>(deserializer: D) -> Result<Vec<Node<Option<N>, Ix>>, D::Error>
- where D: Deserializer<'de>,
- N: Deserialize<'de>,
- Ix: IndexType + Deserialize<'de>,
+fn deser_stable_graph_nodes<'de, D, N, Ix>(
+ deserializer: D,
+) -> Result<Vec<Node<Option<N>, Ix>>, D::Error>
+where
+ D: Deserializer<'de>,
+ N: Deserialize<'de>,
+ Ix: IndexType + Deserialize<'de>,
{
- deserializer.deserialize_seq(MappedSequenceVisitor::new(|n|
+ deserializer.deserialize_seq(MappedSequenceVisitor::new(|n| {
Ok(Node {
weight: Some(n),
next: [EdgeIndex::end(); 2],
})
- ))
+ }))
}
-fn deser_stable_graph_edges<'de, D, N, Ix>(deserializer: D) -> Result<Vec<Edge<Option<N>, Ix>>, D::Error>
- where D: Deserializer<'de>,
- N: Deserialize<'de>,
- Ix: IndexType + Deserialize<'de>,
+fn deser_stable_graph_edges<'de, D, N, Ix>(
+ deserializer: D,
+) -> Result<Vec<Edge<Option<N>, Ix>>, D::Error>
+where
+ D: Deserializer<'de>,
+ N: Deserialize<'de>,
+ Ix: IndexType + Deserialize<'de>,
{
- deserializer.deserialize_seq(MappedSequenceVisitor::<Option<(NodeIndex<Ix>, NodeIndex<Ix>, N)>, _, _>::new(|x|
+ deserializer.deserialize_seq(MappedSequenceVisitor::<
+ Option<(NodeIndex<Ix>, NodeIndex<Ix>, N)>,
+ _,
+ _,
+ >::new(|x| {
if let Some((i, j, w)) = x {
Ok(Edge {
weight: Some(w),
@@ -127,12 +147,13 @@
next: [EdgeIndex::end(); 2],
})
}
- ))
+ }))
}
impl<'a, N, E, Ty, Ix> IntoSerializable for &'a StableGraph<N, E, Ty, Ix>
- where Ix: IndexType,
- Ty: EdgeType,
+where
+ Ix: IndexType,
+ Ty: EdgeType,
{
type Output = SerStableGraph<'a, N, E, Ix>;
fn into_serializable(self) -> Self::Output {
@@ -151,25 +172,29 @@
/// Requires crate feature `"serde-1"`
impl<N, E, Ty, Ix> Serialize for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType + Serialize,
- N: Serialize,
- E: Serialize,
+where
+ Ty: EdgeType,
+ Ix: IndexType + Serialize,
+ N: Serialize,
+ E: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where S: Serializer
+ where
+ S: Serializer,
{
self.into_serializable().serialize(serializer)
}
}
impl<'a, N, E, Ty, Ix> FromDeserialized for StableGraph<N, E, Ty, Ix>
- where Ix: IndexType,
- Ty: EdgeType,
+where
+ Ix: IndexType,
+ Ty: EdgeType,
{
type Input = DeserStableGraph<N, E, Ix>;
fn from_deserialized<E2>(input: Self::Input) -> Result<Self, E2>
- where E2: Error
+ where
+ E2: Error,
{
let ty = PhantomData::<Ty>::from_deserialized(input.edge_property)?;
let mut nodes = input.nodes;
@@ -188,10 +213,13 @@
Err(invalid_node_err(hole_pos.index(), node_bound))?;
}
let insert_pos = hole_pos.index() - offset;
- nodes.insert(insert_pos, Node {
- weight: None,
- next: [EdgeIndex::end(); 2],
- });
+ nodes.insert(
+ insert_pos,
+ Node {
+ weight: None,
+ next: [EdgeIndex::end(); 2],
+ },
+ );
}
if nodes.len() >= <Ix as IndexType>::max().index() {
@@ -210,20 +238,23 @@
free_edge: EdgeIndex::end(),
free_node: NodeIndex::end(),
};
- sgr.link_edges().map_err(|i| invalid_node_err(i.index(), node_bound))?;
+ sgr.link_edges()
+ .map_err(|i| invalid_node_err(i.index(), node_bound))?;
Ok(sgr)
}
}
/// Requires crate feature `"serde-1"`
impl<'de, N, E, Ty, Ix> Deserialize<'de> for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType + Deserialize<'de>,
- N: Deserialize<'de>,
- E: Deserialize<'de>,
+where
+ Ty: EdgeType,
+ Ix: IndexType + Deserialize<'de>,
+ N: Deserialize<'de>,
+ E: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where D: Deserializer<'de>
+ where
+ D: Deserializer<'de>,
{
Self::from_deserialized(DeserStableGraph::deserialize(deserializer)?)
}
@@ -233,8 +264,8 @@
fn test_from_deserialized_with_holes() {
use crate::graph::node_index;
use crate::stable_graph::StableUnGraph;
- use serde::de::value::Error as SerdeError;
use itertools::assert_equal;
+ use serde::de::value::Error as SerdeError;
let input = DeserStableGraph::<_, (), u32> {
nodes: vec![
@@ -251,12 +282,7 @@
next: [EdgeIndex::end(); 2],
},
],
- node_holes: vec![
- node_index(0),
- node_index(2),
- node_index(3),
- node_index(6),
- ],
+ node_holes: vec![node_index(0), node_index(2), node_index(3), node_index(6)],
edges: vec![],
edge_property: EdgeProperty::Undirected,
};
@@ -265,6 +291,6 @@
assert_eq!(graph.node_count(), 3);
assert_equal(
graph.raw_nodes().iter().map(|n| n.weight.as_ref().cloned()),
- vec![None, Some(1), None, None, Some(4), Some(5), None]);
+ vec![None, Some(1), None, None, Some(4), Some(5), None],
+ );
}
-
diff --git a/src/graphmap.rs b/src/graphmap.rs
index 2183235..ecd0d26 100644
--- a/src/graphmap.rs
+++ b/src/graphmap.rs
@@ -1,39 +1,25 @@
//! `GraphMap<N, E, Ty>` is a graph datastructure where node values are mapping
//! keys.
-use std::cmp::Ordering;
-use std::hash::{self, Hash};
-use std::iter::{
- Cloned,
- DoubleEndedIterator,
-};
-use std::slice::{
- Iter,
-};
-use std::fmt;
-use std::ops::{Index, IndexMut, Deref};
-use std::iter::FromIterator;
-use std::marker::PhantomData;
-use indexmap::IndexMap;
-use indexmap::map::{
- Iter as IndexMapIter, IterMut as IndexMapIterMut
-};
use indexmap::map::Keys;
+use indexmap::map::{Iter as IndexMapIter, IterMut as IndexMapIterMut};
+use indexmap::IndexMap;
+use std::cmp::Ordering;
+use std::fmt;
+use std::hash::{self, Hash};
+use std::iter::FromIterator;
+use std::iter::{Cloned, DoubleEndedIterator};
+use std::marker::PhantomData;
+use std::ops::{Deref, Index, IndexMut};
+use std::slice::Iter;
-use crate::{
- EdgeType,
- Directed,
- Undirected,
- Direction,
- Incoming,
- Outgoing,
-};
+use crate::{Directed, Direction, EdgeType, Incoming, Outgoing, Undirected};
-use crate::IntoWeightedEdge;
-use crate::visit::{IntoNodeIdentifiers, NodeCount, IntoNodeReferences, NodeIndexable};
-use crate::visit::{NodeCompactIndexable, IntoEdgeReferences, IntoEdges};
-use crate::graph::Graph;
use crate::graph::node_index;
+use crate::graph::Graph;
+use crate::visit::{IntoEdgeReferences, IntoEdges, NodeCompactIndexable};
+use crate::visit::{IntoNodeIdentifiers, IntoNodeReferences, NodeCount, NodeIndexable};
+use crate::IntoWeightedEdge;
/// A `GraphMap` with undirected edges.
///
@@ -84,7 +70,7 @@
}
/// A trait group for `GraphMap`'s node identifier.
-pub trait NodeTrait : Copy + Ord + Hash {}
+pub trait NodeTrait: Copy + Ord + Hash {}
impl<N> NodeTrait for N where N: Copy + Ord + Hash {}
// non-repr(usize) version of Direction
@@ -110,8 +96,9 @@
}
impl<N, E, Ty> GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
/// Create a new `GraphMap`
pub fn new() -> Self {
@@ -167,8 +154,9 @@
/// ]);
/// ```
pub fn from_edges<I>(iterable: I) -> Self
- where I: IntoIterator,
- I::Item: IntoWeightedEdge<E, NodeId=N>
+ where
+ I: IntoIterator,
+ I::Item: IntoWeightedEdge<E, NodeId = N>,
{
Self::from_iter(iterable)
}
@@ -241,14 +229,16 @@
old
} else {
// insert in the adjacency list if it's a new edge
- self.nodes.entry(a)
- .or_insert_with(|| Vec::with_capacity(1))
- .push((b, CompactDirection::Outgoing));
+ self.nodes
+ .entry(a)
+ .or_insert_with(|| Vec::with_capacity(1))
+ .push((b, CompactDirection::Outgoing));
if a != b {
// self loops don't have the Incoming entry
- self.nodes.entry(b)
- .or_insert_with(|| Vec::with_capacity(1))
- .push((a, CompactDirection::Incoming));
+ self.nodes
+ .entry(b)
+ .or_insert_with(|| Vec::with_capacity(1))
+ .push((a, CompactDirection::Incoming));
}
None
}
@@ -262,13 +252,22 @@
None => false,
Some(sus) => {
if Ty::is_directed() {
- match sus.iter().position(|elt| elt == &(*b, CompactDirection::from(dir))) {
- Some(index) => { sus.swap_remove(index); true }
+ match sus
+ .iter()
+ .position(|elt| elt == &(*b, CompactDirection::from(dir)))
+ {
+ Some(index) => {
+ sus.swap_remove(index);
+ true
+ }
None => false,
}
} else {
match sus.iter().position(|elt| &elt.0 == b) {
- Some(index) => { sus.swap_remove(index); true }
+ Some(index) => {
+ sus.swap_remove(index);
+ true
+ }
None => false,
}
}
@@ -295,7 +294,9 @@
let exist1 = self.remove_single_edge(&a, &b, Outgoing);
let exist2 = if a != b {
self.remove_single_edge(&b, &a, Incoming)
- } else { exist1 };
+ } else {
+ exist1
+ };
let weight = self.edges.remove(&Self::edge_key(a, b));
debug_assert!(exist1 == exist2 && exist1 == weight.is_some());
weight
@@ -310,7 +311,9 @@
///
/// Iterator element type is `N`.
pub fn nodes(&self) -> Nodes<N> {
- Nodes{iter: self.nodes.keys().cloned()}
+ Nodes {
+ iter: self.nodes.keys().cloned(),
+ }
}
/// Return an iterator of all nodes with an edge starting from `a`.
@@ -340,9 +343,7 @@
///
/// Produces an empty iterator if the node doesn't exist.<br>
/// Iterator element type is `N`.
- pub fn neighbors_directed(&self, a: N, dir: Direction)
- -> NeighborsDirected<N, Ty>
- {
+ pub fn neighbors_directed(&self, a: N, dir: Direction) -> NeighborsDirected<N, Ty> {
NeighborsDirected {
iter: match self.nodes.get(&a) {
Some(neigh) => neigh.iter(),
@@ -415,7 +416,8 @@
/// **Panics** if the number of nodes or edges does not fit with
/// the resulting graph's index type.
pub fn into_graph<Ix>(self) -> Graph<N, E, Ty, Ix>
- where Ix: crate::graph::IndexType,
+ where
+ Ix: crate::graph::IndexType,
{
// assuming two successive iterations of the same hashmap produce the same order
let mut gr = Graph::with_capacity(self.node_count(), self.edge_count());
@@ -433,12 +435,14 @@
/// Create a new `GraphMap` from an iterable of edges.
impl<N, E, Ty, Item> FromIterator<Item> for GraphMap<N, E, Ty>
- where Item: IntoWeightedEdge<E, NodeId=N>,
- N: NodeTrait,
- Ty: EdgeType,
+where
+ Item: IntoWeightedEdge<E, NodeId = N>,
+ N: NodeTrait,
+ Ty: EdgeType,
{
fn from_iter<I>(iterable: I) -> Self
- where I: IntoIterator<Item=Item>,
+ where
+ I: IntoIterator<Item = Item>,
{
let iter = iterable.into_iter();
let (low, _) = iter.size_hint();
@@ -452,12 +456,14 @@
///
/// Nodes are inserted automatically to match the edges.
impl<N, E, Ty, Item> Extend<Item> for GraphMap<N, E, Ty>
- where Item: IntoWeightedEdge<E, NodeId=N>,
- N: NodeTrait,
- Ty: EdgeType,
+where
+ Item: IntoWeightedEdge<E, NodeId = N>,
+ N: NodeTrait,
+ Ty: EdgeType,
{
fn extend<I>(&mut self, iterable: I)
- where I: IntoIterator<Item=Item>,
+ where
+ I: IntoIterator<Item = Item>,
{
let iter = iterable.into_iter();
let (low, _) = iter.size_hint();
@@ -502,24 +508,24 @@
}
pub struct Neighbors<'a, N, Ty = Undirected>
- where N: 'a,
- Ty: EdgeType,
+where
+ N: 'a,
+ Ty: EdgeType,
{
iter: Iter<'a, (N, CompactDirection)>,
ty: PhantomData<Ty>,
}
impl<'a, N, Ty> Iterator for Neighbors<'a, N, Ty>
- where N: NodeTrait,
- Ty: EdgeType
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type Item = N;
fn next(&mut self) -> Option<N> {
if Ty::is_directed() {
(&mut self.iter)
- .filter_map(|&(n, dir)| if dir == Outgoing {
- Some(n)
- } else { None })
+ .filter_map(|&(n, dir)| if dir == Outgoing { Some(n) } else { None })
.next()
} else {
self.iter.next().map(|&(n, _)| n)
@@ -528,8 +534,9 @@
}
pub struct NeighborsDirected<'a, N, Ty>
- where N: 'a,
- Ty: EdgeType,
+where
+ N: 'a,
+ Ty: EdgeType,
{
iter: Iter<'a, (N, CompactDirection)>,
start_node: N,
@@ -538,8 +545,9 @@
}
impl<'a, N, Ty> Iterator for NeighborsDirected<'a, N, Ty>
- where N: NodeTrait,
- Ty: EdgeType
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type Item = N;
fn next(&mut self) -> Option<N> {
@@ -547,9 +555,13 @@
let self_dir = self.dir;
let start_node = self.start_node;
(&mut self.iter)
- .filter_map(move |&(n, dir)| if dir == self_dir || n == start_node {
- Some(n)
- } else { None })
+ .filter_map(move |&(n, dir)| {
+ if dir == self_dir || n == start_node {
+ Some(n)
+ } else {
+ None
+ }
+ })
.next()
} else {
self.iter.next().map(|&(n, _)| n)
@@ -558,8 +570,9 @@
}
pub struct Edges<'a, N, E: 'a, Ty>
- where N: 'a + NodeTrait,
- Ty: EdgeType
+where
+ N: 'a + NodeTrait,
+ Ty: EdgeType,
{
from: N,
edges: &'a IndexMap<(N, N), E>,
@@ -567,8 +580,10 @@
}
impl<'a, N, E, Ty> Iterator for Edges<'a, N, E, Ty>
- where N: 'a + NodeTrait, E: 'a,
- Ty: EdgeType,
+where
+ N: 'a + NodeTrait,
+ E: 'a,
+ Ty: EdgeType,
{
type Item = (N, N, &'a E);
fn next(&mut self) -> Option<Self::Item> {
@@ -578,9 +593,7 @@
let a = self.from;
match self.edges.get(&GraphMap::<N, E, Ty>::edge_key(a, b)) {
None => unreachable!(),
- Some(edge) => {
- Some((a, b, edge))
- }
+ Some(edge) => Some((a, b, edge)),
}
}
}
@@ -588,8 +601,9 @@
}
impl<'a, N: 'a, E: 'a, Ty> IntoEdgeReferences for &'a GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type EdgeRef = (N, N, &'a E);
type EdgeReferences = AllEdges<'a, N, E, Ty>;
@@ -598,21 +612,25 @@
}
}
-pub struct AllEdges<'a, N, E: 'a, Ty> where N: 'a + NodeTrait {
+pub struct AllEdges<'a, N, E: 'a, Ty>
+where
+ N: 'a + NodeTrait,
+{
inner: IndexMapIter<'a, (N, N), E>,
ty: PhantomData<Ty>,
}
impl<'a, N, E, Ty> Iterator for AllEdges<'a, N, E, Ty>
- where N: 'a + NodeTrait, E: 'a,
- Ty: EdgeType,
+where
+ N: 'a + NodeTrait,
+ E: 'a,
+ Ty: EdgeType,
{
type Item = (N, N, &'a E);
- fn next(&mut self) -> Option<Self::Item>
- {
+ fn next(&mut self) -> Option<Self::Item> {
match self.inner.next() {
None => None,
- Some((&(a, b), v)) => Some((a, b, v))
+ Some((&(a, b), v)) => Some((a, b, v)),
}
}
@@ -625,35 +643,50 @@
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
- self.inner.nth(n).map(|(&(n1, n2), weight)| (n1, n2, weight))
+ self.inner
+ .nth(n)
+ .map(|(&(n1, n2), weight)| (n1, n2, weight))
}
fn last(self) -> Option<Self::Item> {
- self.inner.last().map(|(&(n1, n2), weight)| (n1, n2, weight))
+ self.inner
+ .last()
+ .map(|(&(n1, n2), weight)| (n1, n2, weight))
}
}
impl<'a, N, E, Ty> DoubleEndedIterator for AllEdges<'a, N, E, Ty>
- where N: 'a + NodeTrait, E: 'a,
- Ty: EdgeType,
+where
+ N: 'a + NodeTrait,
+ E: 'a,
+ Ty: EdgeType,
{
fn next_back(&mut self) -> Option<Self::Item> {
- self.inner.next_back().map(|(&(n1, n2), weight)| (n1, n2, weight))
+ self.inner
+ .next_back()
+ .map(|(&(n1, n2), weight)| (n1, n2, weight))
}
}
-pub struct AllEdgesMut<'a, N, E: 'a, Ty> where N: 'a + NodeTrait {
+pub struct AllEdgesMut<'a, N, E: 'a, Ty>
+where
+ N: 'a + NodeTrait,
+{
inner: IndexMapIterMut<'a, (N, N), E>,
ty: PhantomData<Ty>,
}
impl<'a, N, E, Ty> Iterator for AllEdgesMut<'a, N, E, Ty>
- where N: 'a + NodeTrait, E: 'a,
- Ty: EdgeType,
+where
+ N: 'a + NodeTrait,
+ E: 'a,
+ Ty: EdgeType,
{
type Item = (N, N, &'a mut E);
fn next(&mut self) -> Option<Self::Item> {
- self.inner.next().map(|(&(n1, n2), weight)| (n1, n2, weight))
+ self.inner
+ .next()
+ .map(|(&(n1, n2), weight)| (n1, n2, weight))
}
fn size_hint(&self) -> (usize, Option<usize>) {
@@ -665,26 +698,35 @@
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
- self.inner.nth(n).map(|(&(n1, n2), weight)| (n1, n2, weight))
+ self.inner
+ .nth(n)
+ .map(|(&(n1, n2), weight)| (n1, n2, weight))
}
fn last(self) -> Option<Self::Item> {
- self.inner.last().map(|(&(n1, n2), weight)| (n1, n2, weight))
+ self.inner
+ .last()
+ .map(|(&(n1, n2), weight)| (n1, n2, weight))
}
}
impl<'a, N, E, Ty> DoubleEndedIterator for AllEdgesMut<'a, N, E, Ty>
- where N: 'a + NodeTrait, E: 'a,
- Ty: EdgeType,
+where
+ N: 'a + NodeTrait,
+ E: 'a,
+ Ty: EdgeType,
{
fn next_back(&mut self) -> Option<Self::Item> {
- self.inner.next_back().map(|(&(n1, n2), weight)| (n1, n2, weight))
+ self.inner
+ .next_back()
+ .map(|(&(n1, n2), weight)| (n1, n2, weight))
}
}
impl<'a, N: 'a, E: 'a, Ty> IntoEdges for &'a GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type Edges = Edges<'a, N, E, Ty>;
fn edges(self, a: Self::NodeId) -> Self::Edges {
@@ -692,37 +734,42 @@
}
}
-
/// Index `GraphMap` by node pairs to access edge weights.
impl<N, E, Ty> Index<(N, N)> for GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type Output = E;
- fn index(&self, index: (N, N)) -> &E
- {
+ fn index(&self, index: (N, N)) -> &E {
let index = Self::edge_key(index.0, index.1);
- self.edge_weight(index.0, index.1).expect("GraphMap::index: no such edge")
+ self.edge_weight(index.0, index.1)
+ .expect("GraphMap::index: no such edge")
}
}
/// Index `GraphMap` by node pairs to access edge weights.
impl<N, E, Ty> IndexMut<(N, N)> for GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
fn index_mut(&mut self, index: (N, N)) -> &mut E {
let index = Self::edge_key(index.0, index.1);
- self.edge_weight_mut(index.0, index.1).expect("GraphMap::index: no such edge")
+ self.edge_weight_mut(index.0, index.1)
+ .expect("GraphMap::index: no such edge")
}
}
/// Create a new empty `GraphMap`.
impl<N, E, Ty> Default for GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
- fn default() -> Self { GraphMap::with_capacity(0, 0) }
+ fn default() -> Self {
+ GraphMap::with_capacity(0, 0)
+ }
}
/// A reference that is hashed and compared by its pointer value.
@@ -734,33 +781,30 @@
pub struct Ptr<'b, T: 'b>(pub &'b T);
impl<'b, T> Copy for Ptr<'b, T> {}
-impl<'b, T> Clone for Ptr<'b, T>
-{
- fn clone(&self) -> Self { *self }
+impl<'b, T> Clone for Ptr<'b, T> {
+ fn clone(&self) -> Self {
+ *self
+ }
}
-
fn ptr_eq<T>(a: *const T, b: *const T) -> bool {
a == b
}
-impl<'b, T> PartialEq for Ptr<'b, T>
-{
+impl<'b, T> PartialEq for Ptr<'b, T> {
/// Ptr compares by pointer equality, i.e if they point to the same value
fn eq(&self, other: &Ptr<'b, T>) -> bool {
ptr_eq(self.0, other.0)
}
}
-impl<'b, T> PartialOrd for Ptr<'b, T>
-{
+impl<'b, T> PartialOrd for Ptr<'b, T> {
fn partial_cmp(&self, other: &Ptr<'b, T>) -> Option<Ordering> {
Some(self.cmp(other))
}
}
-impl<'b, T> Ord for Ptr<'b, T>
-{
+impl<'b, T> Ord for Ptr<'b, T> {
/// Ptr is ordered by pointer value, i.e. an arbitrary but stable and total order.
fn cmp(&self, other: &Ptr<'b, T>) -> Ordering {
let a: *const T = self.0;
@@ -778,10 +822,8 @@
impl<'b, T> Eq for Ptr<'b, T> {}
-impl<'b, T> Hash for Ptr<'b, T>
-{
- fn hash<H: hash::Hasher>(&self, st: &mut H)
- {
+impl<'b, T> Hash for Ptr<'b, T> {
+ fn hash<H: hash::Hasher>(&self, st: &mut H) {
let ptr = (self.0) as *const T;
ptr.hash(st)
}
@@ -794,8 +836,9 @@
}
impl<'a, N, E: 'a, Ty> IntoNodeIdentifiers for &'a GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type NodeIdentifiers = NodeIdentifiers<'a, N, E, Ty>;
@@ -809,34 +852,40 @@
}
impl<N, E, Ty> NodeCount for GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
fn node_count(&self) -> usize {
(*self).node_count()
}
}
-pub struct NodeIdentifiers<'a, N, E: 'a, Ty> where N: 'a + NodeTrait {
+pub struct NodeIdentifiers<'a, N, E: 'a, Ty>
+where
+ N: 'a + NodeTrait,
+{
iter: IndexMapIter<'a, N, Vec<(N, CompactDirection)>>,
ty: PhantomData<Ty>,
edge_ty: PhantomData<E>,
}
impl<'a, N, E, Ty> Iterator for NodeIdentifiers<'a, N, E, Ty>
- where N: 'a + NodeTrait, E: 'a,
- Ty: EdgeType,
+where
+ N: 'a + NodeTrait,
+ E: 'a,
+ Ty: EdgeType,
{
type Item = N;
- fn next(&mut self) -> Option<Self::Item>
- {
+ fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(&n, _)| n)
}
}
impl<'a, N, E, Ty> IntoNodeReferences for &'a GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type NodeRef = (N, &'a N);
type NodeReferences = NodeReferences<'a, N, E, Ty>;
@@ -849,28 +898,35 @@
}
}
-pub struct NodeReferences<'a, N, E: 'a, Ty> where N: 'a + NodeTrait {
+pub struct NodeReferences<'a, N, E: 'a, Ty>
+where
+ N: 'a + NodeTrait,
+{
iter: IndexMapIter<'a, N, Vec<(N, CompactDirection)>>,
ty: PhantomData<Ty>,
edge_ty: PhantomData<E>,
}
impl<'a, N, E, Ty> Iterator for NodeReferences<'a, N, E, Ty>
- where N: 'a + NodeTrait, E: 'a,
- Ty: EdgeType,
+where
+ N: 'a + NodeTrait,
+ E: 'a,
+ Ty: EdgeType,
{
type Item = (N, &'a N);
- fn next(&mut self) -> Option<Self::Item>
- {
+ fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(n, _)| (*n, n))
}
}
impl<N, E, Ty> NodeIndexable for GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
- fn node_bound(&self) -> usize { self.node_count() }
+ fn node_bound(&self) -> usize {
+ self.node_count()
+ }
fn to_index(&self, ix: Self::NodeId) -> usize {
let (i, _, _) = self.nodes.get_full(&ix).unwrap();
i
@@ -882,8 +938,8 @@
}
impl<N, E, Ty> NodeCompactIndexable for GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
}
-
diff --git a/src/isomorphism.rs b/src/isomorphism.rs
index e85c328..1d2cd27 100644
--- a/src/isomorphism.rs
+++ b/src/isomorphism.rs
@@ -1,15 +1,8 @@
-use std::marker;
use fixedbitset::FixedBitSet;
+use std::marker;
-use super::{
- EdgeType,
- Incoming,
-};
-use super::graph::{
- Graph,
- IndexType,
- NodeIndex,
-};
+use super::graph::{Graph, IndexType, NodeIndex};
+use super::{EdgeType, Incoming};
use super::visit::GetAdjacencyMatrix;
@@ -35,8 +28,9 @@
}
impl<Ty, Ix> Vf2State<Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
pub fn new<N, E>(g: &Graph<N, E, Ty, Ix>) -> Self {
let c0 = g.node_count();
@@ -66,9 +60,12 @@
}
/// Add mapping **from** <-> **to** to the state.
- pub fn push_mapping<N, E>(&mut self, from: NodeIndex<Ix>, to: NodeIndex<Ix>,
- g: &Graph<N, E, Ty, Ix>)
- {
+ pub fn push_mapping<N, E>(
+ &mut self,
+ from: NodeIndex<Ix>,
+ to: NodeIndex<Ix>,
+ g: &Graph<N, E, Ty, Ix>,
+ ) {
self.generation += 1;
let s = self.generation;
self.mapping[from.index()] = to;
@@ -92,9 +89,7 @@
}
/// Restore the state to before the last added mapping
- pub fn pop_mapping<N, E>(&mut self, from: NodeIndex<Ix>,
- g: &Graph<N, E, Ty, Ix>)
- {
+ pub fn pop_mapping<N, E>(&mut self, from: NodeIndex<Ix>, g: &Graph<N, E, Ty, Ix>) {
let s = self.generation;
self.generation -= 1;
@@ -119,39 +114,40 @@
}
/// Find the next (least) node in the Tout set.
- pub fn next_out_index(&self, from_index: usize) -> Option<usize>
- {
- self.out[from_index..].iter()
- .enumerate()
- .find(move |&(index, elt)| *elt > 0 &&
- self.mapping[from_index + index] == NodeIndex::end())
- .map(|(index, _)| index)
+ pub fn next_out_index(&self, from_index: usize) -> Option<usize> {
+ self.out[from_index..]
+ .iter()
+ .enumerate()
+ .find(move |&(index, elt)| {
+ *elt > 0 && self.mapping[from_index + index] == NodeIndex::end()
+ })
+ .map(|(index, _)| index)
}
/// Find the next (least) node in the Tin set.
- pub fn next_in_index(&self, from_index: usize) -> Option<usize>
- {
+ pub fn next_in_index(&self, from_index: usize) -> Option<usize> {
if !Ty::is_directed() {
- return None
+ return None;
}
- self.ins[from_index..].iter()
- .enumerate()
- .find(move |&(index, elt)| *elt > 0
- && self.mapping[from_index + index] == NodeIndex::end())
- .map(|(index, _)| index)
+ self.ins[from_index..]
+ .iter()
+ .enumerate()
+ .find(move |&(index, elt)| {
+ *elt > 0 && self.mapping[from_index + index] == NodeIndex::end()
+ })
+ .map(|(index, _)| index)
}
/// Find the next (least) node in the N - M set.
- pub fn next_rest_index(&self, from_index: usize) -> Option<usize>
- {
- self.mapping[from_index..].iter()
- .enumerate()
- .find(|&(_, elt)| *elt == NodeIndex::end())
- .map(|(index, _)| index)
+ pub fn next_rest_index(&self, from_index: usize) -> Option<usize> {
+ self.mapping[from_index..]
+ .iter()
+ .enumerate()
+ .find(|&(_, elt)| *elt == NodeIndex::end())
+ .map(|(index, _)| index)
}
}
-
/// [Graph] Return `true` if the graphs `g0` and `g1` are isomorphic.
///
/// Using the VF2 algorithm, only matching graph syntactically (graph
@@ -163,13 +159,13 @@
///
/// * Luigi P. Cordella, Pasquale Foggia, Carlo Sansone, Mario Vento;
/// *A (Sub)Graph Isomorphism Algorithm for Matching Large Graphs*
-pub fn is_isomorphic<N, E, Ty, Ix>(g0: &Graph<N, E, Ty, Ix>,
- g1: &Graph<N, E, Ty, Ix>) -> bool
- where Ty: EdgeType,
- Ix: IndexType,
+pub fn is_isomorphic<N, E, Ty, Ix>(g0: &Graph<N, E, Ty, Ix>, g1: &Graph<N, E, Ty, Ix>) -> bool
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
if g0.node_count() != g1.node_count() || g0.edge_count() != g1.edge_count() {
- return false
+ return false;
}
let mut st = [Vf2State::new(g0), Vf2State::new(g1)];
@@ -182,17 +178,20 @@
/// graph isomorphism (graph structure and matching node and edge weights).
///
/// The graphs should not be multigraphs.
-pub fn is_isomorphic_matching<N, E, Ty, Ix, F, G>(g0: &Graph<N, E, Ty, Ix>,
- g1: &Graph<N, E, Ty, Ix>,
- mut node_match: F,
- mut edge_match: G) -> bool
- where Ty: EdgeType,
- Ix: IndexType,
- F: FnMut(&N, &N) -> bool,
- G: FnMut(&E, &E) -> bool,
+pub fn is_isomorphic_matching<N, E, Ty, Ix, F, G>(
+ g0: &Graph<N, E, Ty, Ix>,
+ g1: &Graph<N, E, Ty, Ix>,
+ mut node_match: F,
+ mut edge_match: G,
+) -> bool
+where
+ Ty: EdgeType,
+ Ix: IndexType,
+ F: FnMut(&N, &N) -> bool,
+ G: FnMut(&E, &E) -> bool,
{
if g0.node_count() != g1.node_count() || g0.edge_count() != g1.edge_count() {
- return false
+ return false;
}
let mut st = [Vf2State::new(g0), Vf2State::new(g1)];
@@ -208,29 +207,42 @@
impl<T> SemanticMatcher<T> for NoSemanticMatch {
#[inline]
- fn enabled() -> bool { false }
+ fn enabled() -> bool {
+ false
+ }
#[inline]
- fn eq(&mut self, _: &T, _: &T) -> bool { true }
+ fn eq(&mut self, _: &T, _: &T) -> bool {
+ true
+ }
}
-impl<T, F> SemanticMatcher<T> for F where F: FnMut(&T, &T) -> bool {
+impl<T, F> SemanticMatcher<T> for F
+where
+ F: FnMut(&T, &T) -> bool,
+{
#[inline]
- fn enabled() -> bool { true }
+ fn enabled() -> bool {
+ true
+ }
#[inline]
- fn eq(&mut self, a: &T, b: &T) -> bool { self(a, b) }
+ fn eq(&mut self, a: &T, b: &T) -> bool {
+ self(a, b)
+ }
}
/// Return Some(bool) if isomorphism is decided, else None.
-fn try_match<N, E, Ty, Ix, F, G>(mut st: &mut [Vf2State<Ty, Ix>; 2],
- g0: &Graph<N, E, Ty, Ix>,
- g1: &Graph<N, E, Ty, Ix>,
- node_match: &mut F,
- edge_match: &mut G)
- -> Option<bool>
- where Ty: EdgeType,
- Ix: IndexType,
- F: SemanticMatcher<N>,
- G: SemanticMatcher<E>,
+fn try_match<N, E, Ty, Ix, F, G>(
+ mut st: &mut [Vf2State<Ty, Ix>; 2],
+ g0: &Graph<N, E, Ty, Ix>,
+ g1: &Graph<N, E, Ty, Ix>,
+ node_match: &mut F,
+ edge_match: &mut G,
+) -> Option<bool>
+where
+ Ty: EdgeType,
+ Ix: IndexType,
+ F: SemanticMatcher<N>,
+ G: SemanticMatcher<E>,
{
if st[0].is_complete() {
return Some(true);
@@ -254,77 +266,81 @@
#[derive(Clone, PartialEq, Debug)]
enum Frame<N: marker::Copy> {
Outer,
- Inner{ nodes: [N; 2], open_list: OpenList },
- Unwind{ nodes: [N; 2], open_list: OpenList },
+ Inner { nodes: [N; 2], open_list: OpenList },
+ Unwind { nodes: [N; 2], open_list: OpenList },
}
- let next_candidate = |st: &mut[Vf2State<Ty, Ix>; 2]|
- -> Option<(NodeIndex<Ix>, NodeIndex<Ix>, OpenList)> {
- let mut to_index;
- let mut from_index = None;
- let mut open_list = OpenList::Out;
- // Try the out list
- to_index = st[1].next_out_index(0);
-
- if to_index.is_some() {
- from_index = st[0].next_out_index(0);
- open_list = OpenList::Out;
- }
- // Try the in list
- if to_index.is_none() || from_index.is_none() {
- to_index = st[1].next_in_index(0);
+ let next_candidate =
+ |st: &mut [Vf2State<Ty, Ix>; 2]| -> Option<(NodeIndex<Ix>, NodeIndex<Ix>, OpenList)> {
+ let mut to_index;
+ let mut from_index = None;
+ let mut open_list = OpenList::Out;
+ // Try the out list
+ to_index = st[1].next_out_index(0);
if to_index.is_some() {
- from_index = st[0].next_in_index(0);
- open_list = OpenList::In;
+ from_index = st[0].next_out_index(0);
+ open_list = OpenList::Out;
}
- }
- // Try the other list -- disconnected graph
- if to_index.is_none() || from_index.is_none() {
- to_index = st[1].next_rest_index(0);
- if to_index.is_some() {
- from_index = st[0].next_rest_index(0);
- open_list = OpenList::Other;
+ // Try the in list
+ if to_index.is_none() || from_index.is_none() {
+ to_index = st[1].next_in_index(0);
+
+ if to_index.is_some() {
+ from_index = st[0].next_in_index(0);
+ open_list = OpenList::In;
+ }
}
- }
- match (from_index, to_index) {
- (Some(n), Some(m)) => Some((NodeIndex::new(n), NodeIndex::new(m), open_list)),
- // No more candidates
- _ => None,
- }
- };
- let next_from_ix = |st: &mut[Vf2State<Ty, Ix>; 2], nx: NodeIndex<Ix>, open_list: OpenList| -> Option<NodeIndex<Ix>> {
+ // Try the other list -- disconnected graph
+ if to_index.is_none() || from_index.is_none() {
+ to_index = st[1].next_rest_index(0);
+ if to_index.is_some() {
+ from_index = st[0].next_rest_index(0);
+ open_list = OpenList::Other;
+ }
+ }
+ match (from_index, to_index) {
+ (Some(n), Some(m)) => Some((NodeIndex::new(n), NodeIndex::new(m), open_list)),
+ // No more candidates
+ _ => None,
+ }
+ };
+ let next_from_ix = |st: &mut [Vf2State<Ty, Ix>; 2],
+ nx: NodeIndex<Ix>,
+ open_list: OpenList|
+ -> Option<NodeIndex<Ix>> {
// Find the next node index to try on the `from` side of the mapping
let start = nx.index() + 1;
let cand0 = match open_list {
OpenList::Out => st[0].next_out_index(start),
OpenList::In => st[0].next_in_index(start),
OpenList::Other => st[0].next_rest_index(start),
- }.map(|c| c + start); // compensate for start offset.
+ }
+ .map(|c| c + start); // compensate for start offset.
match cand0 {
None => None, // no more candidates
Some(ix) => {
debug_assert!(ix >= start);
Some(NodeIndex::new(ix))
- },
+ }
}
};
//fn pop_state(nodes: [NodeIndex<Ix>; 2]) {
- let pop_state = |st: &mut[Vf2State<Ty, Ix>; 2], nodes: [NodeIndex<Ix>; 2]| {
+ let pop_state = |st: &mut [Vf2State<Ty, Ix>; 2], nodes: [NodeIndex<Ix>; 2]| {
// Restore state.
for j in graph_indices.clone() {
st[j].pop_mapping(nodes[j], g[j]);
}
};
//fn push_state(nodes: [NodeIndex<Ix>; 2]) {
- let push_state = |st: &mut[Vf2State<Ty, Ix>; 2],nodes: [NodeIndex<Ix>; 2]| {
+ let push_state = |st: &mut [Vf2State<Ty, Ix>; 2], nodes: [NodeIndex<Ix>; 2]| {
// Add mapping nx <-> mx to the state
for j in graph_indices.clone() {
- st[j].push_mapping(nodes[j], nodes[1-j], g[j]);
+ st[j].push_mapping(nodes[j], nodes[1 - j], g[j]);
}
};
//fn is_feasible(nodes: [NodeIndex<Ix>; 2]) -> bool {
- let mut is_feasible = |st: &mut[Vf2State<Ty, Ix>; 2], nodes: [NodeIndex<Ix>; 2]| -> bool {
+ let mut is_feasible = |st: &mut [Vf2State<Ty, Ix>; 2], nodes: [NodeIndex<Ix>; 2]| -> bool {
// Check syntactic feasibility of mapping by ensuring adjacencies
// of nx map to adjacencies of mx.
//
@@ -355,7 +371,8 @@
if m_neigh == end {
continue;
}
- let has_edge = g[1-j].is_adjacent(&st[1-j].adjacency_matrix, nodes[1-j], m_neigh);
+ let has_edge =
+ g[1 - j].is_adjacent(&st[1 - j].adjacency_matrix, nodes[1 - j], m_neigh);
if !has_edge {
return false;
}
@@ -375,7 +392,8 @@
if m_neigh == end {
continue;
}
- let has_edge = g[1-j].is_adjacent(&st[1-j].adjacency_matrix, m_neigh, nodes[1-j]);
+ let has_edge =
+ g[1 - j].is_adjacent(&st[1 - j].adjacency_matrix, m_neigh, nodes[1 - j]);
if !has_edge {
return false;
}
@@ -404,13 +422,13 @@
if m_neigh == end {
continue;
}
- match g[1-j].find_edge(nodes[1 - j], m_neigh) {
+ match g[1 - j].find_edge(nodes[1 - j], m_neigh) {
Some(m_edge) => {
- if !edge_match.eq(&g[j][n_edge], &g[1-j][m_edge]) {
+ if !edge_match.eq(&g[j][n_edge], &g[1 - j][m_edge]) {
return false;
}
}
- None => unreachable!() // covered by syntactic check
+ None => unreachable!(), // covered by syntactic check
}
}
}
@@ -424,13 +442,13 @@
if m_neigh == end {
continue;
}
- match g[1-j].find_edge(m_neigh, nodes[1-j]) {
+ match g[1 - j].find_edge(m_neigh, nodes[1 - j]) {
Some(m_edge) => {
- if !edge_match.eq(&g[j][n_edge], &g[1-j][m_edge]) {
+ if !edge_match.eq(&g[j][n_edge], &g[1 - j][m_edge]) {
return false;
}
}
- None => unreachable!() // covered by syntactic check
+ None => unreachable!(), // covered by syntactic check
}
}
}
@@ -442,46 +460,61 @@
while let Some(frame) = stack.pop() {
match frame {
- Frame::Unwind{nodes, open_list: ol} => {
+ Frame::Unwind {
+ nodes,
+ open_list: ol,
+ } => {
pop_state(&mut st, nodes);
match next_from_ix(&mut st, nodes[0], ol) {
None => continue,
Some(nx) => {
- let f = Frame::Inner{nodes: [nx, nodes[1]], open_list: ol};
+ let f = Frame::Inner {
+ nodes: [nx, nodes[1]],
+ open_list: ol,
+ };
stack.push(f);
}
}
}
- Frame::Outer => {
- match next_candidate(&mut st) {
- None => continue,
- Some((nx, mx, ol)) => {
- let f = Frame::Inner{nodes: [nx, mx], open_list: ol};
- stack.push(f);
- }
+ Frame::Outer => match next_candidate(&mut st) {
+ None => continue,
+ Some((nx, mx, ol)) => {
+ let f = Frame::Inner {
+ nodes: [nx, mx],
+ open_list: ol,
+ };
+ stack.push(f);
}
- }
- Frame::Inner{nodes, open_list: ol} => {
+ },
+ Frame::Inner {
+ nodes,
+ open_list: ol,
+ } => {
if is_feasible(&mut st, nodes) {
push_state(&mut st, nodes);
if st[0].is_complete() {
return Some(true);
}
// Check cardinalities of Tin, Tout sets
- if st[0].out_size == st[1].out_size &&
- st[0].ins_size == st[1].ins_size {
- let f0 = Frame::Unwind{nodes, open_list: ol};
- stack.push(f0);
- stack.push(Frame::Outer);
- continue;
+ if st[0].out_size == st[1].out_size && st[0].ins_size == st[1].ins_size {
+ let f0 = Frame::Unwind {
+ nodes,
+ open_list: ol,
+ };
+ stack.push(f0);
+ stack.push(Frame::Outer);
+ continue;
}
pop_state(&mut st, nodes);
}
match next_from_ix(&mut st, nodes[0], ol) {
None => continue,
Some(nx) => {
- let f = Frame::Inner{nodes: [nx, nodes[1]], open_list: ol};
+ let f = Frame::Inner {
+ nodes: [nx, nodes[1]],
+ open_list: ol,
+ };
stack.push(f);
}
}
diff --git a/src/iter_format.rs b/src/iter_format.rs
index de03a2a..f6ffd6a 100644
--- a/src/iter_format.rs
+++ b/src/iter_format.rs
@@ -7,15 +7,14 @@
pub struct DebugMap<F>(pub F);
impl<'a, F, I, K, V> fmt::Debug for DebugMap<F>
- where F: Fn() -> I,
- I: IntoIterator<Item=(K, V)>,
- K: fmt::Debug,
- V: fmt::Debug,
+where
+ F: Fn() -> I,
+ I: IntoIterator<Item = (K, V)>,
+ K: fmt::Debug,
+ V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.debug_map()
- .entries((self.0)())
- .finish()
+ f.debug_map().entries((self.0)()).finish()
}
}
@@ -23,7 +22,8 @@
pub struct NoPretty<T>(pub T);
impl<T> fmt::Debug for NoPretty<T>
- where T: fmt::Debug,
+where
+ T: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?}", self.0)
@@ -44,9 +44,10 @@
inner: RefCell<Option<I>>,
}
-pub trait IterFormatExt : Iterator {
+pub trait IterFormatExt: Iterator {
fn format(self, separator: &str) -> Format<Self>
- where Self: Sized
+ where
+ Self: Sized,
{
Format {
sep: separator,
@@ -55,14 +56,15 @@
}
}
-impl<I> IterFormatExt for I where I: Iterator { }
-
+impl<I> IterFormatExt for I where I: Iterator {}
impl<'a, I> Format<'a, I>
- where I: Iterator,
+where
+ I: Iterator,
{
fn format<F>(&self, f: &mut fmt::Formatter, mut cb: F) -> fmt::Result
- where F: FnMut(&I::Item, &mut fmt::Formatter) -> fmt::Result,
+ where
+ F: FnMut(&I::Item, &mut fmt::Formatter) -> fmt::Result,
{
let mut iter = match self.inner.borrow_mut().take() {
Some(t) => t,
diff --git a/src/iter_utils.rs b/src/iter_utils.rs
index 30db2d5..587af84 100644
--- a/src/iter_utils.rs
+++ b/src/iter_utils.rs
@@ -1,9 +1,9 @@
-
-pub trait IterUtilsExt : Iterator {
+pub trait IterUtilsExt: Iterator {
/// Return the first element that maps to `Some(_)`, or None if the iterator
/// was exhausted.
fn ex_find_map<F, R>(&mut self, mut f: F) -> Option<R>
- where F: FnMut(Self::Item) -> Option<R>
+ where
+ F: FnMut(Self::Item) -> Option<R>,
{
for elt in self {
if let result @ Some(_) = f(elt) {
@@ -16,8 +16,9 @@
/// Return the last element from the back that maps to `Some(_)`, or
/// None if the iterator was exhausted.
fn ex_rfind_map<F, R>(&mut self, mut f: F) -> Option<R>
- where F: FnMut(Self::Item) -> Option<R>,
- Self: DoubleEndedIterator,
+ where
+ F: FnMut(Self::Item) -> Option<R>,
+ Self: DoubleEndedIterator,
{
while let Some(elt) = self.next_back() {
if let result @ Some(_) = f(elt) {
@@ -28,4 +29,4 @@
}
}
-impl<I> IterUtilsExt for I where I: Iterator { }
+impl<I> IterUtilsExt for I where I: Iterator {}
diff --git a/src/lib.rs b/src/lib.rs
index aaaec0c..d475884 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,5 @@
-
//! `petgraph` is a graph data structure library.
-//!
+//!
//! Graphs are collections of nodes, and edges between nodes. `petgraph`
//! provides several [graph types](index.html#graph-types) (each differing in the
//! tradeoffs taken in their internal representation),
@@ -8,9 +7,9 @@
//! [output graphs](./doc/petgraph/dot/struct.Dot.html) in
//! [`graphviz`](https://www.graphviz.org/) format. Both nodes and edges
//! can have arbitrary associated data, and edges may be either directed or undirected.
-//!
+//!
//! # Example
-//!
+//!
//! ```rust
//! use petgraph::graph::{NodeIndex, UnGraph};
//! use petgraph::algo::{dijkstra, min_spanning_tree};
@@ -45,7 +44,7 @@
//! ```
//!
//! # Graph types
-//!
+//!
//! * [`Graph`](./graph/struct.Graph.html) -
//! An adjacency list graph with arbitrary associated data.
//! * [`StableGraph`](./stable_graph/struct.StableGraph.html) -
@@ -59,11 +58,11 @@
//! A sparse adjacency matrix graph with arbitrary associated data.
//!
//! ### Generic parameters
-//!
+//!
//! Each graph type is generic over a handful of parameters. All graphs share 3 common
//! parameters, `N`, `E`, and `Ty`. This is a broad overview of what those are. Each
//! type's documentation will have finer detail on these parameters.
-//!
+//!
//! `N` & `E` are called *weights* in this implementation, and are associated with
//! nodes and edges respectively. They can generally be of arbitrary type, and don't have to
//! be what you might conventionally consider weight-like. For example, using `&str` for `N`
@@ -74,25 +73,25 @@
//! implement [`PartialOrd`](https://doc.rust-lang.org/stable/core/cmp/trait.PartialOrd.html).
//! [`GraphMap`](./graphmap/struct.GraphMap.html) requires node weights that can serve as hash
//! map keys, since that graph type does not create standalone node indices.
-//!
+//!
//! `Ty` controls whether edges are [`Directed`](./petgraph/enum.Directed.html) or
//! [`Undirected`](./petgraph/enum.Unirected.html).
-//!
+//!
//! `Ix` appears on graph types that use indices. It is exposed so you can control
//! the size of node and edge indices, and therefore the memory footprint of your graphs.
//! Allowed values are `u8`, `u16`, `u32`, and `usize`, with `u32` being the default.
-//!
+//!
//! ### Shorthand types
-//!
+//!
//! Each graph type vends a few shorthand type definitions that name some specific
//! generic choices. For example, [`DiGraph<_, _>`](./graph/type.DiGraph.html) is shorthand
//! for [`Graph<_, _, Undirected>`](graph/struct.Graph.html).
//! [`UnMatrix<_, _>`](./matrix_graph/type.UnMatrix.html) is shorthand for
//! [`MatrixGraph<_, _, Undirected>`](./matrix_graph/struct.MatrixGraph.html). Each graph type's
//! module documentation lists the available shorthand types.
-//!
+//!
//! # Crate features
-//!
+//!
//! * **serde-1** -
//! Defaults off. Enables serialization for ``Graph, StableGraph`` using
//! [`serde 1.0`](https://crates.io/crates/serde). May require a more recent version
@@ -122,7 +121,7 @@
#[doc(no_inline)]
pub use crate::graph::Graph;
-pub use crate::Direction::{Outgoing, Incoming};
+pub use crate::Direction::{Incoming, Outgoing};
#[macro_use]
mod macros;
@@ -135,58 +134,38 @@
pub mod data;
pub mod algo;
+mod astar;
+pub mod csr;
+mod dijkstra;
+pub mod dot;
#[cfg(feature = "generate")]
pub mod generate;
+mod graph_impl;
#[cfg(feature = "graphmap")]
pub mod graphmap;
-#[cfg(feature = "matrix_graph")]
-pub mod matrix_graph;
-mod graph_impl;
-pub mod dot;
-pub mod unionfind;
-mod dijkstra;
-mod astar;
-mod simple_paths;
-pub mod csr;
+mod isomorphism;
mod iter_format;
mod iter_utils;
-mod isomorphism;
-mod traits_graph;
-mod util;
+#[cfg(feature = "matrix_graph")]
+pub mod matrix_graph;
#[cfg(feature = "quickcheck")]
mod quickcheck;
#[cfg(feature = "serde-1")]
mod serde_utils;
+mod simple_paths;
+mod traits_graph;
+pub mod unionfind;
+mod util;
pub mod prelude;
/// `Graph<N, E, Ty, Ix>` is a graph datastructure using an adjacency list representation.
pub mod graph {
pub use crate::graph_impl::{
- Edge,
- EdgeIndex,
- EdgeIndices,
- EdgeReference,
- EdgeReferences,
- EdgeWeightsMut,
- Edges,
- Externals,
- Frozen,
- Graph,
- Neighbors,
- Node,
- NodeIndex,
- NodeIndices,
- NodeWeightsMut,
- NodeReferences,
+ edge_index, node_index, DefaultIx, DiGraph, Edge, EdgeIndex, EdgeIndices, EdgeReference,
+ EdgeReferences, EdgeWeightsMut, Edges, Externals, Frozen, Graph, GraphIndex, IndexType,
+ Neighbors, Node, NodeIndex, NodeIndices, NodeReferences, NodeWeightsMut, UnGraph,
WalkNeighbors,
- GraphIndex,
- IndexType,
- edge_index,
- node_index,
- DefaultIx,
- DiGraph,
- UnGraph,
};
}
@@ -197,9 +176,11 @@
($name:ident) => {
impl Clone for $name {
#[inline]
- fn clone(&self) -> Self { *self }
+ fn clone(&self) -> Self {
+ *self
+ }
}
- }
+ };
}
// Index into the NodeIndex and EdgeIndex arrays
@@ -210,7 +191,7 @@
/// An `Outgoing` edge is an outward edge *from* the current node.
Outgoing = 0,
/// An `Incoming` edge is an inbound edge *to* the current node.
- Incoming = 1
+ Incoming = 1,
}
copyclone!(Direction);
@@ -237,12 +218,12 @@
/// Marker type for a directed graph.
#[derive(Copy, Debug)]
-pub enum Directed { }
+pub enum Directed {}
copyclone!(Directed);
/// Marker type for an undirected graph.
#[derive(Copy, Debug)]
-pub enum Undirected { }
+pub enum Undirected {}
copyclone!(Undirected);
/// A graph's edge type determines whether it has directed edges or not.
@@ -252,15 +233,18 @@
impl EdgeType for Directed {
#[inline]
- fn is_directed() -> bool { true }
+ fn is_directed() -> bool {
+ true
+ }
}
impl EdgeType for Undirected {
#[inline]
- fn is_directed() -> bool { false }
+ fn is_directed() -> bool {
+ false
+ }
}
-
/// Convert an element like `(i, j)` or `(i, j, w)` into
/// a triple of source, target, edge weight.
///
@@ -271,7 +255,8 @@
}
impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
- where E: Default
+where
+ E: Default,
{
type NodeId = Ix;
@@ -281,8 +266,7 @@
}
}
-impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix, E)
-{
+impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix, E) {
type NodeId = Ix;
fn into_weighted_edge(self) -> (Ix, Ix, E) {
self
@@ -290,7 +274,8 @@
}
impl<'a, Ix, E> IntoWeightedEdge<E> for (Ix, Ix, &'a E)
- where E: Clone
+where
+ E: Clone,
{
type NodeId = Ix;
fn into_weighted_edge(self) -> (Ix, Ix, E) {
@@ -300,7 +285,9 @@
}
impl<'a, Ix, E> IntoWeightedEdge<E> for &'a (Ix, Ix)
- where Ix: Copy, E: Default
+where
+ Ix: Copy,
+ E: Default,
{
type NodeId = Ix;
fn into_weighted_edge(self) -> (Ix, Ix, E) {
@@ -310,7 +297,9 @@
}
impl<'a, Ix, E> IntoWeightedEdge<E> for &'a (Ix, Ix, E)
- where Ix: Copy, E: Clone
+where
+ Ix: Copy,
+ E: Clone,
{
type NodeId = Ix;
fn into_weighted_edge(self) -> (Ix, Ix, E) {
diff --git a/src/macros.rs b/src/macros.rs
index 964372f..0d86ad1 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,4 +1,3 @@
-
macro_rules! clone_fields {
($name:ident, $($field:ident),+ $(,)*) => (
fn clone(&self) -> Self {
@@ -10,4 +9,3 @@
}
);
}
-
diff --git a/src/matrix_graph.rs b/src/matrix_graph.rs
index d64747c..0e0c26c 100644
--- a/src/matrix_graph.rs
+++ b/src/matrix_graph.rs
@@ -10,32 +10,14 @@
use fixedbitset::FixedBitSet;
-use crate::{
- Directed,
- EdgeType,
- Outgoing,
- Undirected,
- Direction,
- IntoWeightedEdge,
-};
+use crate::{Directed, Direction, EdgeType, IntoWeightedEdge, Outgoing, Undirected};
use crate::graph::NodeIndex as GraphNodeIndex;
use crate::visit::{
- Data,
- GetAdjacencyMatrix,
- GraphBase,
- GraphProp,
- IntoEdgeReferences,
- IntoEdges,
- IntoNeighbors,
- IntoNeighborsDirected,
- IntoNodeIdentifiers,
- IntoNodeReferences,
- NodeCount,
- NodeIndexable,
- NodeCompactIndexable,
- Visitable,
+ Data, GetAdjacencyMatrix, GraphBase, GraphProp, IntoEdgeReferences, IntoEdges, IntoNeighbors,
+ IntoNeighborsDirected, IntoNodeIdentifiers, IntoNodeReferences, NodeCompactIndexable,
+ NodeCount, NodeIndexable, Visitable,
};
use crate::data::Build;
@@ -48,7 +30,7 @@
type DefaultIx = u16;
/// Node identifier.
-pub type NodeIndex<Ix=DefaultIx> = GraphNodeIndex<Ix>;
+pub type NodeIndex<Ix = DefaultIx> = GraphNodeIndex<Ix>;
mod private {
pub trait Sealed {}
@@ -125,20 +107,29 @@
}
fn as_ref(&self) -> Option<&Self::Wrapped> {
- if !self.is_null() { Some(&self.0) }
- else { None }
+ if !self.is_null() {
+ Some(&self.0)
+ } else {
+ None
+ }
}
fn as_mut(&mut self) -> Option<&mut Self::Wrapped> {
- if !self.is_null() { Some(&mut self.0) }
- else { None }
+ if !self.is_null() {
+ Some(&mut self.0)
+ } else {
+ None
+ }
}
}
impl<T: Zero> Into<Option<T>> for NotZero<T> {
fn into(self) -> Option<T> {
- if !self.is_null() { Some(self.0) }
- else { None }
+ if !self.is_null() {
+ Some(self.0)
+ } else {
+ None
+ }
}
}
@@ -167,7 +158,7 @@
self == &Self::zero()
}
}
- }
+ };
}
macro_rules! not_zero_impls {
@@ -208,7 +199,8 @@
/// matrix is stored. Since the backing array stores edge weights, it is recommended to box large
/// edge weights.
#[derive(Clone)]
-pub struct MatrixGraph<N, E, Ty = Directed, Null: Nullable<Wrapped=E> = Option<E>, Ix = DefaultIx> {
+pub struct MatrixGraph<N, E, Ty = Directed, Null: Nullable<Wrapped = E> = Option<E>, Ix = DefaultIx>
+{
node_adjacencies: Vec<Null>,
node_capacity: usize,
nodes: IdStorage<N>,
@@ -223,7 +215,9 @@
/// A `MatrixGraph` with undirected edges.
pub type UnMatrix<N, E, Null = Option<E>, Ix = DefaultIx> = MatrixGraph<N, E, Undirected, Null, Ix>;
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType>
+ MatrixGraph<N, E, Ty, Null, Ix>
+{
/// Create a new `MatrixGraph` with estimated capacity for nodes.
pub fn with_capacity(node_capacity: usize) -> Self {
let mut m = Self {
@@ -309,7 +303,11 @@
#[inline]
fn extend_capacity_for_node(&mut self, min_node: NodeIndex<Ix>) {
- self.node_capacity = extend_linearized_matrix::<Ty, _>(&mut self.node_adjacencies, self.node_capacity, min_node.index());
+ self.node_capacity = extend_linearized_matrix::<Ty, _>(
+ &mut self.node_adjacencies,
+ self.node_capacity,
+ min_node.index(),
+ );
}
#[inline]
@@ -363,7 +361,9 @@
/// **Panics** if no edge exists between `a` and `b`.
pub fn remove_edge(&mut self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> E {
let p = self.to_edge_position(a, b);
- let old_weight = mem::replace(&mut self.node_adjacencies[p], Default::default()).into().unwrap();
+ let old_weight = mem::replace(&mut self.node_adjacencies[p], Default::default())
+ .into()
+ .unwrap();
let old_weight: Option<_> = old_weight.into();
self.nb_edges -= 1;
old_weight.unwrap()
@@ -423,7 +423,11 @@
/// Produces an empty iterator if the node doesn't exist.<br>
/// Iterator element type is [`NodeIndex<Ix>`](../graph/struct.NodeIndex.html).
pub fn neighbors(&self, a: NodeIndex<Ix>) -> Neighbors<Ty, Null, Ix> {
- Neighbors(Edges::on_columns(a.index(), &self.node_adjacencies, self.node_capacity))
+ Neighbors(Edges::on_columns(
+ a.index(),
+ &self.node_adjacencies,
+ self.node_capacity,
+ ))
}
/// Return an iterator of all edges of `a`.
@@ -455,10 +459,11 @@
/// ]);
/// ```
pub fn from_edges<I>(iterable: I) -> Self
- where I: IntoIterator,
- I::Item: IntoWeightedEdge<E>,
- <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
- N: Default,
+ where
+ I: IntoIterator,
+ I::Item: IntoWeightedEdge<E>,
+ <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
+ N: Default,
{
let mut g = Self::default();
g.extend_with_edges(iterable);
@@ -473,10 +478,11 @@
///
/// Nodes are inserted automatically to match the edges.
pub fn extend_with_edges<I>(&mut self, iterable: I)
- where I: IntoIterator,
- I::Item: IntoWeightedEdge<E>,
- <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
- N: Default,
+ where
+ I: IntoIterator,
+ I::Item: IntoWeightedEdge<E>,
+ <I::Item as IntoWeightedEdge<E>>::NodeId: Into<NodeIndex<Ix>>,
+ N: Default,
{
for elt in iterable {
let (source, target, weight) = elt.into_weighted_edge();
@@ -490,7 +496,7 @@
}
}
-impl<N, E, Null: Nullable<Wrapped=E>, Ix: IndexType> MatrixGraph<N, E, Directed, Null, Ix> {
+impl<N, E, Null: Nullable<Wrapped = E>, Ix: IndexType> MatrixGraph<N, E, Directed, Null, 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)*.
@@ -500,11 +506,19 @@
///
/// Produces an empty iterator if the node doesn't exist.<br>
/// Iterator element type is [`NodeIndex<Ix>`](../graph/struct.NodeIndex.html).
- pub fn neighbors_directed(&self, a: NodeIndex<Ix>, d: Direction) -> Neighbors<Directed, Null, Ix> {
+ pub fn neighbors_directed(
+ &self,
+ a: NodeIndex<Ix>,
+ d: Direction,
+ ) -> Neighbors<Directed, Null, Ix> {
if d == Outgoing {
self.neighbors(a)
} else {
- Neighbors(Edges::on_rows(a.index(), &self.node_adjacencies, self.node_capacity))
+ Neighbors(Edges::on_rows(
+ a.index(),
+ &self.node_adjacencies,
+ self.node_capacity,
+ ))
}
}
@@ -537,7 +551,10 @@
impl<'a, Ix: IndexType> NodeIdentifiers<'a, Ix> {
fn new(iter: IdIterator<'a>) -> Self {
- Self { iter, ix: PhantomData }
+ Self {
+ iter,
+ ix: PhantomData,
+ }
}
}
@@ -575,7 +592,9 @@
type Item = (NodeIndex<Ix>, &'a N);
fn next(&mut self) -> Option<Self::Item> {
- self.iter.next().map(|i| (NodeIndex::new(i), &self.nodes[i]))
+ self.iter
+ .next()
+ .map(|i| (NodeIndex::new(i), &self.nodes[i]))
}
}
@@ -597,7 +616,8 @@
impl<'a, Ty: EdgeType, Null: 'a + Nullable, Ix> EdgeReferences<'a, Ty, Null, Ix> {
fn new(node_adjacencies: &'a [Null], node_capacity: usize) -> Self {
EdgeReferences {
- row: 0, column: 0,
+ row: 0,
+ column: 0,
node_adjacencies,
node_capacity,
ty: PhantomData,
@@ -606,7 +626,9 @@
}
}
-impl<'a, Ty: EdgeType, Null: Nullable, Ix: IndexType> Iterator for EdgeReferences<'a, Ty, Null, Ix> {
+impl<'a, Ty: EdgeType, Null: Nullable, Ix: IndexType> Iterator
+ for EdgeReferences<'a, Ty, Null, Ix>
+{
type Item = (NodeIndex<Ix>, NodeIndex<Ix>, &'a Null::Wrapped);
fn next(&mut self) -> Option<Self::Item> {
@@ -621,7 +643,11 @@
// Note that for undirected graphs, we don't want to yield the same edge twice,
// therefore the maximum column length should be the index new after the row index.
self.column += 1;
- let max_column_len = if !Ty::is_directed() { row + 1 } else { self.node_capacity };
+ let max_column_len = if !Ty::is_directed() {
+ row + 1
+ } else {
+ self.node_capacity
+ };
if self.column >= max_column_len {
self.column = 0;
self.row += 1;
@@ -713,14 +739,14 @@
}
match self.iter_direction {
- Rows => self.row += 1,
+ Rows => self.row += 1,
Columns => self.column += 1,
}
let p = to_linearized_matrix_position::<Ty>(row, column, self.node_capacity);
if let Some(e) = self.node_adjacencies[p].as_ref() {
let (a, b) = match self.iter_direction {
- Rows => (column, row),
+ Rows => (column, row),
Columns => (row, column),
};
@@ -740,7 +766,11 @@
}
#[inline]
-fn extend_linearized_matrix<Ty: EdgeType, T: Default>(node_adjacencies: &mut Vec<T>, old_node_capacity: usize, min_node_capacity: usize) -> usize {
+fn extend_linearized_matrix<Ty: EdgeType, T: Default>(
+ node_adjacencies: &mut Vec<T>,
+ old_node_capacity: usize,
+ min_node_capacity: usize,
+) -> usize {
if Ty::is_directed() {
extend_flat_square_matrix(node_adjacencies, old_node_capacity, min_node_capacity)
} else {
@@ -754,7 +784,11 @@
}
#[inline]
-fn extend_flat_square_matrix<T: Default>(node_adjacencies: &mut Vec<T>, old_node_capacity: usize, min_node_capacity: usize) -> usize {
+fn extend_flat_square_matrix<T: Default>(
+ node_adjacencies: &mut Vec<T>,
+ old_node_capacity: usize,
+ min_node_capacity: usize,
+) -> usize {
let min_node_capacity = (min_node_capacity + 1).next_power_of_two();
// Optimization: when resizing the matrix this way we skip the first few grows to make
@@ -782,12 +816,19 @@
#[inline]
fn to_lower_triangular_matrix_position(row: usize, column: usize) -> usize {
- let (row, column) = if row > column { (row, column) } else { (column, row) };
+ let (row, column) = if row > column {
+ (row, column)
+ } else {
+ (column, row)
+ };
(row * (row + 1)) / 2 + column
}
#[inline]
-fn extend_lower_triangular_matrix<T: Default>(node_adjacencies: &mut Vec<T>, new_node_capacity: usize) -> usize {
+fn extend_lower_triangular_matrix<T: Default>(
+ node_adjacencies: &mut Vec<T>,
+ new_node_capacity: usize,
+) -> usize {
let max_pos = to_lower_triangular_matrix_position(new_node_capacity, new_node_capacity);
ensure_len(node_adjacencies, max_pos + 1);
new_node_capacity + 1
@@ -915,7 +956,9 @@
}
/// Create a new empty `MatrixGraph`.
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> Default for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> Default
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
fn default() -> Self {
Self::with_capacity(0)
}
@@ -944,7 +987,9 @@
/// Index the `MatrixGraph` by `NodeIndex` to access node weights.
///
/// **Panics** if the node doesn't exist.
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> Index<NodeIndex<Ix>> for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> Index<NodeIndex<Ix>>
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
type Output = N;
fn index(&self, ax: NodeIndex<Ix>) -> &N {
@@ -955,13 +1000,17 @@
/// Index the `MatrixGraph` by `NodeIndex` to access node weights.
///
/// **Panics** if the node doesn't exist.
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> IndexMut<NodeIndex<Ix>> for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> IndexMut<NodeIndex<Ix>>
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
fn index_mut(&mut self, ax: NodeIndex<Ix>) -> &mut N {
self.node_weight_mut(ax)
}
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> NodeCount for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> NodeCount
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
fn node_count(&self) -> usize {
MatrixGraph::node_count(self)
}
@@ -972,7 +1021,9 @@
/// Also available with indexing syntax: `&graph[e]`.
///
/// **Panics** if no edge exists between `a` and `b`.
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> Index<(NodeIndex<Ix>, NodeIndex<Ix>)> for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType>
+ Index<(NodeIndex<Ix>, NodeIndex<Ix>)> for MatrixGraph<N, E, Ty, Null, Ix>
+{
type Output = E;
fn index(&self, (ax, bx): (NodeIndex<Ix>, NodeIndex<Ix>)) -> &E {
@@ -985,24 +1036,29 @@
/// Also available with indexing syntax: `&mut graph[e]`.
///
/// **Panics** if no edge exists between `a` and `b`.
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> IndexMut<(NodeIndex<Ix>, NodeIndex<Ix>)> for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType>
+ IndexMut<(NodeIndex<Ix>, NodeIndex<Ix>)> for MatrixGraph<N, E, Ty, Null, Ix>
+{
fn index_mut(&mut self, (ax, bx): (NodeIndex<Ix>, NodeIndex<Ix>)) -> &mut E {
self.edge_weight_mut(ax, bx)
}
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> GetAdjacencyMatrix for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> GetAdjacencyMatrix
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
type AdjMatrix = ();
- fn adjacency_matrix(&self) -> Self::AdjMatrix {
- }
+ fn adjacency_matrix(&self) -> Self::AdjMatrix {}
fn is_adjacent(&self, _: &Self::AdjMatrix, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool {
MatrixGraph::has_edge(self, a, b)
}
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> Visitable for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> Visitable
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
type Map = FixedBitSet;
fn visit_map(&self) -> FixedBitSet {
@@ -1015,21 +1071,29 @@
}
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> GraphBase for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> GraphBase
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
type NodeId = NodeIndex<Ix>;
type EdgeId = (NodeIndex<Ix>, NodeIndex<Ix>);
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> GraphProp for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> GraphProp
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
type EdgeType = Ty;
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> Data for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> Data
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
type NodeWeight = N;
type EdgeWeight = E;
}
-impl<'a, N, E: 'a, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> IntoNodeIdentifiers for &'a MatrixGraph<N, E, Ty, Null, Ix> {
+impl<'a, N, E: 'a, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> IntoNodeIdentifiers
+ for &'a MatrixGraph<N, E, Ty, Null, Ix>
+{
type NodeIdentifiers = NodeIdentifiers<'a, Ix>;
fn node_identifiers(self) -> Self::NodeIdentifiers {
@@ -1037,7 +1101,9 @@
}
}
-impl<'a, N, E: 'a, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> IntoNeighbors for &'a MatrixGraph<N, E, Ty, Null, Ix> {
+impl<'a, N, E: 'a, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> IntoNeighbors
+ for &'a MatrixGraph<N, E, Ty, Null, Ix>
+{
type Neighbors = Neighbors<'a, Ty, Null, Ix>;
fn neighbors(self, a: NodeIndex<Ix>) -> Self::Neighbors {
@@ -1045,7 +1111,9 @@
}
}
-impl<'a, N, E: 'a, Null: Nullable<Wrapped=E>, Ix: IndexType> IntoNeighborsDirected for &'a MatrixGraph<N, E, Directed, Null, Ix> {
+impl<'a, N, E: 'a, Null: Nullable<Wrapped = E>, Ix: IndexType> IntoNeighborsDirected
+ for &'a MatrixGraph<N, E, Directed, Null, Ix>
+{
type NeighborsDirected = Neighbors<'a, Directed, Null, Ix>;
fn neighbors_directed(self, a: NodeIndex<Ix>, d: Direction) -> Self::NeighborsDirected {
@@ -1053,7 +1121,9 @@
}
}
-impl<'a, N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> IntoNodeReferences for &'a MatrixGraph<N, E, Ty, Null, Ix> {
+impl<'a, N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> IntoNodeReferences
+ for &'a MatrixGraph<N, E, Ty, Null, Ix>
+{
type NodeRef = (NodeIndex<Ix>, &'a N);
type NodeReferences = NodeReferences<'a, N, Ix>;
fn node_references(self) -> Self::NodeReferences {
@@ -1061,7 +1131,9 @@
}
}
-impl<'a, N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> IntoEdgeReferences for &'a MatrixGraph<N, E, Ty, Null, Ix> {
+impl<'a, N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> IntoEdgeReferences
+ for &'a MatrixGraph<N, E, Ty, Null, Ix>
+{
type EdgeRef = (NodeIndex<Ix>, NodeIndex<Ix>, &'a E);
type EdgeReferences = EdgeReferences<'a, Ty, Null, Ix>;
fn edge_references(self) -> Self::EdgeReferences {
@@ -1069,14 +1141,18 @@
}
}
-impl<'a, N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> IntoEdges for &'a MatrixGraph<N, E, Ty, Null, Ix> {
+impl<'a, N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> IntoEdges
+ for &'a MatrixGraph<N, E, Ty, Null, Ix>
+{
type Edges = Edges<'a, Ty, Null, Ix>;
fn edges(self, a: Self::NodeId) -> Self::Edges {
MatrixGraph::edges(self, a)
}
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> NodeIndexable for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> NodeIndexable
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
fn node_bound(&self) -> usize {
self.node_count()
}
@@ -1090,15 +1166,24 @@
}
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> NodeCompactIndexable for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> NodeCompactIndexable
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
}
-impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped=E>, Ix: IndexType> Build for MatrixGraph<N, E, Ty, Null, Ix> {
+impl<N, E, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> Build
+ for MatrixGraph<N, E, Ty, Null, Ix>
+{
fn add_node(&mut self, weight: Self::NodeWeight) -> Self::NodeId {
self.add_node(weight)
}
- fn add_edge(&mut self, a: Self::NodeId, b: Self::NodeId, weight: Self::EdgeWeight) -> Option<Self::EdgeId> {
+ fn add_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Option<Self::EdgeId> {
if !self.has_edge(a, b) {
MatrixGraph::update_edge(self, a, b, weight);
Some((a, b))
@@ -1107,7 +1192,12 @@
}
}
- fn update_edge(&mut self, a: Self::NodeId, b: Self::NodeId, weight: Self::EdgeWeight) -> Self::EdgeId {
+ fn update_edge(
+ &mut self,
+ a: Self::NodeId,
+ b: Self::NodeId,
+ weight: Self::EdgeWeight,
+ ) -> Self::EdgeId {
MatrixGraph::update_edge(self, a, b, weight);
(a, b)
}
@@ -1116,7 +1206,7 @@
#[cfg(test)]
mod tests {
use super::*;
- use crate::{Outgoing, Incoming};
+ use crate::{Incoming, Outgoing};
#[test]
fn test_new() {
@@ -1206,7 +1296,8 @@
}
impl<It, T> IntoVec<T> for It
- where It: Iterator<Item=T>,
+ where
+ It: Iterator<Item = T>,
{
fn into_vec(self) -> Vec<T> {
self.collect()
@@ -1281,8 +1372,9 @@
}
impl<It, T> IntoSortedVec<T> for It
- where It: Iterator<Item=T>,
- T: Ord,
+ where
+ It: Iterator<Item = T>,
+ T: Ord,
{
fn into_sorted_vec(self) -> Vec<T> {
let mut v: Vec<T> = self.collect();
@@ -1401,9 +1493,13 @@
#[test]
fn test_edges_directed() {
let g: MatrixGraph<char, bool> = MatrixGraph::from_edges(&[
- (0, 5), (0, 2), (0, 3), (0, 1),
+ (0, 5),
+ (0, 2),
+ (0, 3),
+ (0, 1),
(1, 3),
- (2, 3), (2, 4),
+ (2, 3),
+ (2, 4),
(4, 0),
(6, 6),
]);
@@ -1428,9 +1524,13 @@
#[test]
fn test_edges_undirected() {
let g: UnMatrix<char, bool> = UnMatrix::from_edges(&[
- (0, 5), (0, 2), (0, 3), (0, 1),
+ (0, 5),
+ (0, 2),
+ (0, 3),
+ (0, 1),
(1, 3),
- (2, 3), (2, 4),
+ (2, 3),
+ (2, 4),
(4, 0),
(6, 6),
]);
@@ -1459,9 +1559,13 @@
#[test]
fn test_edge_references() {
let g: MatrixGraph<char, bool> = MatrixGraph::from_edges(&[
- (0, 5), (0, 2), (0, 3), (0, 1),
+ (0, 5),
+ (0, 2),
+ (0, 3),
+ (0, 1),
(1, 3),
- (2, 3), (2, 4),
+ (2, 3),
+ (2, 4),
(4, 0),
(6, 6),
]);
@@ -1472,9 +1576,13 @@
#[test]
fn test_edge_references_undirected() {
let g: UnMatrix<char, bool> = UnMatrix::from_edges(&[
- (0, 5), (0, 2), (0, 3), (0, 1),
+ (0, 5),
+ (0, 2),
+ (0, 3),
+ (0, 1),
(1, 3),
- (2, 3), (2, 4),
+ (2, 3),
+ (2, 4),
(4, 0),
(6, 6),
]);
diff --git a/src/prelude.rs b/src/prelude.rs
index d35161e..f50b338 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -1,4 +1,3 @@
-
//! Commonly used items.
//!
//! ```
@@ -6,43 +5,17 @@
//! ```
#[doc(no_inline)]
-pub use crate::graph::{
- Graph,
- NodeIndex,
- EdgeIndex,
- DiGraph,
- UnGraph,
-};
+pub use crate::graph::{DiGraph, EdgeIndex, Graph, NodeIndex, UnGraph};
#[cfg(feature = "graphmap")]
#[doc(no_inline)]
-pub use crate::graphmap::{
- GraphMap,
- DiGraphMap,
- UnGraphMap,
-};
+pub use crate::graphmap::{DiGraphMap, GraphMap, UnGraphMap};
#[doc(no_inline)]
#[cfg(feature = "stable_graph")]
-pub use crate::stable_graph::{
- StableGraph,
- StableDiGraph,
- StableUnGraph,
-};
+pub use crate::stable_graph::{StableDiGraph, StableGraph, StableUnGraph};
#[doc(no_inline)]
-pub use crate::visit::{
- Bfs,
- Dfs,
- DfsPostOrder,
-};
+pub use crate::visit::{Bfs, Dfs, DfsPostOrder};
#[doc(no_inline)]
-pub use crate::{
- Direction,
- Incoming,
- Outgoing,
- Directed,
- Undirected,
-};
+pub use crate::{Directed, Direction, Incoming, Outgoing, Undirected};
#[doc(no_inline)]
-pub use crate::visit::{
- EdgeRef,
-};
+pub use crate::visit::EdgeRef;
diff --git a/src/quickcheck.rs b/src/quickcheck.rs
index 7ce6cad..0c7ce6b 100644
--- a/src/quickcheck.rs
+++ b/src/quickcheck.rs
@@ -1,22 +1,13 @@
extern crate quickcheck;
-use self::quickcheck::{Gen, Arbitrary};
+use self::quickcheck::{Arbitrary, Gen};
-use crate::{
- Graph,
- EdgeType,
-};
-use crate::graph::{
- IndexType,
- node_index,
-};
+use crate::graph::{node_index, IndexType};
#[cfg(feature = "stable_graph")]
use crate::stable_graph::StableGraph;
+use crate::{EdgeType, Graph};
#[cfg(feature = "graphmap")]
-use crate::graphmap::{
- GraphMap,
- NodeTrait,
-};
+use crate::graphmap::{GraphMap, NodeTrait};
use crate::visit::NodeIndexable;
/// Return a random float in the range [0, 1.)
@@ -38,10 +29,11 @@
///
/// Requires crate feature `"quickcheck"`
impl<N, E, Ty, Ix> Arbitrary for Graph<N, E, Ty, Ix>
- where N: Arbitrary,
- E: Arbitrary,
- Ty: EdgeType + Send + 'static,
- Ix: IndexType + Send,
+where
+ N: Arbitrary,
+ E: Arbitrary,
+ Ty: EdgeType + Send + 'static,
+ Ix: IndexType + Send,
{
fn arbitrary<G: Gen>(g: &mut G) -> Self {
let nodes = usize::arbitrary(g);
@@ -71,17 +63,18 @@
// shrink the graph by splitting it in two by a very
// simple algorithm, just even and odd node indices
- fn shrink(&self) -> Box<dyn Iterator<Item=Self>> {
+ fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
let self_ = self.clone();
Box::new((0..2).filter_map(move |x| {
- let gr = self_.filter_map(|i, w| {
- if i.index() % 2 == x {
- Some(w.clone())
- } else {
- None
- }
- },
- |_, w| Some(w.clone())
+ let gr = self_.filter_map(
+ |i, w| {
+ if i.index() % 2 == x {
+ Some(w.clone())
+ } else {
+ None
+ }
+ },
+ |_, w| Some(w.clone()),
);
// make sure we shrink
if gr.node_count() < self_.node_count() {
@@ -104,10 +97,11 @@
///
/// Requires crate features `"quickcheck"` and `"stable_graph"`
impl<N, E, Ty, Ix> Arbitrary for StableGraph<N, E, Ty, Ix>
- where N: Arbitrary,
- E: Arbitrary,
- Ty: EdgeType + Send + 'static,
- Ix: IndexType + Send,
+where
+ N: Arbitrary,
+ E: Arbitrary,
+ Ty: EdgeType + Send + 'static,
+ Ix: IndexType + Send,
{
fn arbitrary<G: Gen>(g: &mut G) -> Self {
let nodes = usize::arbitrary(g);
@@ -149,17 +143,18 @@
// shrink the graph by splitting it in two by a very
// simple algorithm, just even and odd node indices
- fn shrink(&self) -> Box<dyn Iterator<Item=Self>> {
+ fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
let self_ = self.clone();
Box::new((0..2).filter_map(move |x| {
- let gr = self_.filter_map(|i, w| {
- if i.index() % 2 == x {
- Some(w.clone())
- } else {
- None
- }
- },
- |_, w| Some(w.clone())
+ let gr = self_.filter_map(
+ |i, w| {
+ if i.index() % 2 == x {
+ Some(w.clone())
+ } else {
+ None
+ }
+ },
+ |_, w| Some(w.clone()),
);
// make sure we shrink
if gr.node_count() < self_.node_count() {
@@ -182,9 +177,10 @@
/// Requires crate features `"quickcheck"` and `"graphmap"`
#[cfg(feature = "graphmap")]
impl<N, E, Ty> Arbitrary for GraphMap<N, E, Ty>
- where N: NodeTrait + Arbitrary,
- E: Arbitrary,
- Ty: EdgeType + Clone + Send + 'static,
+where
+ N: NodeTrait + Arbitrary,
+ E: Arbitrary,
+ Ty: EdgeType + Clone + Send + 'static,
{
fn arbitrary<G: Gen>(g: &mut G) -> Self {
let nodes = usize::arbitrary(g);
@@ -203,7 +199,11 @@
gr.add_node(node);
}
for (index, &i) in nodes.iter().enumerate() {
- let js = if Ty::is_directed() { &nodes[..] } else { &nodes[index..] };
+ let js = if Ty::is_directed() {
+ &nodes[..]
+ } else {
+ &nodes[index..]
+ };
for &j in js {
let p: f64 = random_01(g);
if p <= edge_prob {
diff --git a/src/scored.rs b/src/scored.rs
index cb19147..a4f88a9 100644
--- a/src/scored.rs
+++ b/src/scored.rs
@@ -50,4 +50,3 @@
}
}
}
-
diff --git a/src/serde_utils.rs b/src/serde_utils.rs
index fcda128..f127f33 100644
--- a/src/serde_utils.rs
+++ b/src/serde_utils.rs
@@ -1,7 +1,7 @@
+use serde::de::{Deserialize, Error, SeqAccess, Visitor};
+use serde::ser::{Serialize, SerializeSeq, Serializer};
use std::fmt;
use std::marker::PhantomData;
-use serde::de::{Error, Visitor, Deserialize, SeqAccess};
-use serde::ser::{Serializer, SerializeSeq, Serialize};
/// Map to serializeable representation
pub trait IntoSerializable {
@@ -10,25 +10,27 @@
}
/// Map from deserialized representation
-pub trait FromDeserialized : Sized {
+pub trait FromDeserialized: Sized {
type Input;
- fn from_deserialized<E>(input: Self::Input) -> Result<Self, E> where E: Error;
+ fn from_deserialized<E>(input: Self::Input) -> Result<Self, E>
+ where
+ E: Error;
}
-
-
/// Serde combinator. A sequence visitor that maps deserialized elements
/// lazily; the visitor can also emit new errors if the elements have errors.
pub struct MappedSequenceVisitor<T, R, F>
- where F: Fn(T) -> Result<R, &'static str>
+where
+ F: Fn(T) -> Result<R, &'static str>,
{
f: F,
- marker: PhantomData<fn() -> T>
+ marker: PhantomData<fn() -> T>,
}
-impl<'de, F, T, R> MappedSequenceVisitor<T, R, F>
- where T: Deserialize<'de>,
- F: Fn(T) -> Result<R, &'static str>,
+impl<'de, F, T, R> MappedSequenceVisitor<T, R, F>
+where
+ T: Deserialize<'de>,
+ F: Fn(T) -> Result<R, &'static str>,
{
pub fn new(f: F) -> Self {
MappedSequenceVisitor {
@@ -38,9 +40,10 @@
}
}
-impl<'de, F, T, R> Visitor<'de> for MappedSequenceVisitor<T, R, F>
- where T: Deserialize<'de>,
- F: Fn(T) -> Result<R, &'static str>,
+impl<'de, F, T, R> Visitor<'de> for MappedSequenceVisitor<T, R, F>
+where
+ T: Deserialize<'de>,
+ F: Fn(T) -> Result<R, &'static str>,
{
type Value = Vec<R>;
@@ -48,7 +51,8 @@
write!(formatter, "a sequence")
}
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
- where A: SeqAccess<'de>,
+ where
+ A: SeqAccess<'de>,
{
let mut v = Vec::new();
while let Some(elem) = seq.next_element()? {
@@ -61,12 +65,11 @@
}
}
-
-pub trait CollectSeqWithLength : Serializer {
- fn collect_seq_with_length<I>(self, length: usize, iterable: I)
- -> Result<Self::Ok, Self::Error>
- where I: IntoIterator,
- I::Item: Serialize
+pub trait CollectSeqWithLength: Serializer {
+ fn collect_seq_with_length<I>(self, length: usize, iterable: I) -> Result<Self::Ok, Self::Error>
+ where
+ I: IntoIterator,
+ I::Item: Serialize,
{
let mut count = 0;
let mut seq = self.serialize_seq(Some(length))?;
@@ -78,15 +81,15 @@
seq.end()
}
- fn collect_seq_exact<I>(self, iterable: I)
- -> Result<Self::Ok, Self::Error>
- where I: IntoIterator,
- I::Item: Serialize,
- I::IntoIter: ExactSizeIterator,
+ fn collect_seq_exact<I>(self, iterable: I) -> Result<Self::Ok, Self::Error>
+ where
+ I: IntoIterator,
+ I::Item: Serialize,
+ I::IntoIter: ExactSizeIterator,
{
let iter = iterable.into_iter();
self.collect_seq_with_length(iter.len(), iter)
}
}
-impl<S> CollectSeqWithLength for S where S: Serializer { }
+impl<S> CollectSeqWithLength for S where S: Serializer {}
diff --git a/src/simple_paths.rs b/src/simple_paths.rs
index 7d698df..76be84e 100644
--- a/src/simple_paths.rs
+++ b/src/simple_paths.rs
@@ -6,26 +6,26 @@
use indexmap::IndexSet;
use crate::{
+ visit::{IntoNeighborsDirected, NodeCount},
Direction::Outgoing,
- visit::{
- IntoNeighborsDirected,
- NodeCount,
- },
};
/// Returns iterator that produces all simple paths from `from` node to `to`, which contains at least `min_intermidiate_nodes` nodes
/// and at most `max_intermidiate_nodes`, if given, limited by graph's order otherwise
/// Simple path is path without repetitions
/// Algorithm is adopted from https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.simple_paths.all_simple_paths.html
-pub fn all_simple_paths<TargetColl, G>(graph: G,
- from: G::NodeId,
- to: G::NodeId,
- min_intermidiate_nodes: usize,
- max_intermidiate_nodes: Option<usize>) -> impl Iterator<Item=TargetColl>
- where G: NodeCount,
- G: IntoNeighborsDirected,
- G::NodeId: Eq + Hash,
- TargetColl: FromIterator<G::NodeId>
+pub fn all_simple_paths<TargetColl, G>(
+ graph: G,
+ from: G::NodeId,
+ to: G::NodeId,
+ min_intermidiate_nodes: usize,
+ max_intermidiate_nodes: Option<usize>,
+) -> impl Iterator<Item = TargetColl>
+where
+ G: NodeCount,
+ G: IntoNeighborsDirected,
+ G::NodeId: Eq + Hash,
+ TargetColl: FromIterator<G::NodeId>,
{
// how many nodes are allowed in simple path up to target node
// it is min/max allowed path length minus one, because it is more appropriate when implementing lookahead
@@ -50,7 +50,11 @@
if visited.len() < max_length {
if child == to {
if visited.len() >= min_length {
- let path = visited.iter().cloned().chain(Some(to)).collect::<TargetColl>();
+ let path = visited
+ .iter()
+ .cloned()
+ .chain(Some(to))
+ .collect::<TargetColl>();
return Some(path);
}
} else if !visited.contains(&child) {
@@ -59,7 +63,11 @@
}
} else {
if (child == to || children.any(|v| v == to)) && visited.len() >= min_length {
- let path = visited.iter().cloned().chain(Some(to)).collect::<TargetColl>();
+ let path = visited
+ .iter()
+ .cloned()
+ .chain(Some(to))
+ .collect::<TargetColl>();
return Some(path);
}
stack.pop();
@@ -76,17 +84,11 @@
#[cfg(test)]
mod test {
- use std::{
- collections::HashSet,
- iter::FromIterator,
- };
+ use std::{collections::HashSet, iter::FromIterator};
use itertools::assert_equal;
- use crate::{
- dot::Dot,
- prelude::DiGraph,
- };
+ use crate::{dot::Dot, prelude::DiGraph};
use super::all_simple_paths;
@@ -105,7 +107,7 @@
(4, 2),
(4, 5),
(5, 2),
- (5, 3)
+ (5, 3),
]);
let expexted_simple_paths_0_to_5 = vec![
@@ -120,27 +122,27 @@
];
println!("{}", Dot::new(&graph));
- let actual_simple_paths_0_to_5: HashSet<Vec<_>> = all_simple_paths(&graph, 0u32.into(), 5u32.into(), 0, None)
- .map(|v: Vec<_>| v.into_iter().map(|i| i.index()).collect())
- .collect();
+ let actual_simple_paths_0_to_5: HashSet<Vec<_>> =
+ all_simple_paths(&graph, 0u32.into(), 5u32.into(), 0, None)
+ .map(|v: Vec<_>| v.into_iter().map(|i| i.index()).collect())
+ .collect();
assert_eq!(actual_simple_paths_0_to_5.len(), 8);
- assert_eq!(HashSet::from_iter(expexted_simple_paths_0_to_5), actual_simple_paths_0_to_5);
+ assert_eq!(
+ HashSet::from_iter(expexted_simple_paths_0_to_5),
+ actual_simple_paths_0_to_5
+ );
}
#[test]
fn test_one_simple_path() {
- let graph = DiGraph::<i32, i32, _>::from_edges(&[
- (0, 1),
- (2, 1)
- ]);
+ let graph = DiGraph::<i32, i32, _>::from_edges(&[(0, 1), (2, 1)]);
- let expexted_simple_paths_0_to_1 = &[
- vec![0usize, 1],
- ];
+ let expexted_simple_paths_0_to_1 = &[vec![0usize, 1]];
println!("{}", Dot::new(&graph));
- let actual_simple_paths_0_to_1: Vec<Vec<_>> = all_simple_paths(&graph, 0u32.into(), 1u32.into(), 0, None)
- .map(|v: Vec<_>| v.into_iter().map(|i| i.index()).collect())
- .collect();
+ let actual_simple_paths_0_to_1: Vec<Vec<_>> =
+ all_simple_paths(&graph, 0u32.into(), 1u32.into(), 0, None)
+ .map(|v: Vec<_>| v.into_iter().map(|i| i.index()).collect())
+ .collect();
assert_eq!(actual_simple_paths_0_to_1.len(), 1);
assert_equal(expexted_simple_paths_0_to_1, &actual_simple_paths_0_to_1);
@@ -148,15 +150,13 @@
#[test]
fn test_no_simple_paths() {
- let graph = DiGraph::<i32, i32, _>::from_edges(&[
- (0, 1),
- (2, 1)
- ]);
+ let graph = DiGraph::<i32, i32, _>::from_edges(&[(0, 1), (2, 1)]);
println!("{}", Dot::new(&graph));
- let actual_simple_paths_0_to_2: Vec<Vec<_>> = all_simple_paths(&graph, 0u32.into(), 2u32.into(), 0, None)
- .map(|v: Vec<_>| v.into_iter().map(|i| i.index()).collect())
- .collect();
+ let actual_simple_paths_0_to_2: Vec<Vec<_>> =
+ all_simple_paths(&graph, 0u32.into(), 2u32.into(), 0, None)
+ .map(|v: Vec<_>| v.into_iter().map(|i| i.index()).collect())
+ .collect();
assert_eq!(actual_simple_paths_0_to_2.len(), 0);
}
diff --git a/src/traits_graph.rs b/src/traits_graph.rs
index 1eef177..272e9e7 100644
--- a/src/traits_graph.rs
+++ b/src/traits_graph.rs
@@ -1,33 +1,26 @@
-
use fixedbitset::FixedBitSet;
-use super::{
- EdgeType,
-};
+use super::EdgeType;
-use super::graph::{
- Graph,
- IndexType,
- NodeIndex,
-};
+use super::graph::{Graph, IndexType, NodeIndex};
#[cfg(feature = "stable_graph")]
use crate::stable_graph::StableGraph;
-#[cfg(feature = "stable_graph")]
-use crate::visit::{NodeIndexable, IntoEdgeReferences};
use crate::visit::EdgeRef;
+#[cfg(feature = "stable_graph")]
+use crate::visit::{IntoEdgeReferences, NodeIndexable};
use super::visit::GetAdjacencyMatrix;
/// The adjacency matrix for **Graph** is a bitmap that's computed by
/// `.adjacency_matrix()`.
-impl<N, E, Ty, Ix> GetAdjacencyMatrix for Graph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> GetAdjacencyMatrix for Graph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
type AdjMatrix = FixedBitSet;
- fn adjacency_matrix(&self) -> FixedBitSet
- {
+ fn adjacency_matrix(&self) -> FixedBitSet {
let n = self.node_count();
let mut matrix = FixedBitSet::with_capacity(n * n);
for edge in self.edge_references() {
@@ -41,26 +34,24 @@
matrix
}
- fn is_adjacent(&self, matrix: &FixedBitSet, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool
- {
+ fn is_adjacent(&self, matrix: &FixedBitSet, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool {
let n = self.node_count();
let index = n * a.index() + b.index();
matrix.contains(index)
}
}
-
#[cfg(feature = "stable_graph")]
/// The adjacency matrix for **Graph** is a bitmap that's computed by
/// `.adjacency_matrix()`.
-impl<N, E, Ty, Ix> GetAdjacencyMatrix for StableGraph<N, E, Ty, Ix> where
+impl<N, E, Ty, Ix> GetAdjacencyMatrix for StableGraph<N, E, Ty, Ix>
+where
Ty: EdgeType,
Ix: IndexType,
{
type AdjMatrix = FixedBitSet;
- fn adjacency_matrix(&self) -> FixedBitSet
- {
+ fn adjacency_matrix(&self) -> FixedBitSet {
let n = self.node_bound();
let mut matrix = FixedBitSet::with_capacity(n * n);
for edge in self.edge_references() {
@@ -74,12 +65,9 @@
matrix
}
- fn is_adjacent(&self, matrix: &FixedBitSet, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool
- {
+ fn is_adjacent(&self, matrix: &FixedBitSet, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool {
let n = self.node_count();
let index = n * a.index() + b.index();
matrix.contains(index)
}
}
-
-
diff --git a/src/unionfind.rs b/src/unionfind.rs
index e64d8b6..2f6b12c 100644
--- a/src/unionfind.rs
+++ b/src/unionfind.rs
@@ -1,7 +1,7 @@
//! `UnionFind<K>` is a disjoint-set data structure.
-use std::cmp::Ordering;
use super::graph::IndexType;
+use std::cmp::Ordering;
/// `UnionFind<K>` is a disjoint-set data structure. It tracks set membership of *n* elements
/// indexed from *0* to *n - 1*. The scalar type is `K` which must be an unsigned integer type.
@@ -13,8 +13,7 @@
/// “The amortized time per operation is **O(α(n))** where **α(n)** is the
/// inverse of **f(x) = A(x, x)** with **A** being the extremely fast-growing Ackermann function.”
#[derive(Debug, Clone)]
-pub struct UnionFind<K>
-{
+pub struct UnionFind<K> {
// For element at index *i*, store the index of its parent; the representative itself
// stores its own index. This forms equivalence classes which are the disjoint sets, each
// with a unique representative.
@@ -28,36 +27,33 @@
}
#[inline]
-unsafe fn get_unchecked<K>(xs: &[K], index: usize) -> &K
-{
+unsafe fn get_unchecked<K>(xs: &[K], index: usize) -> &K {
debug_assert!(index < xs.len());
xs.get_unchecked(index)
}
#[inline]
-unsafe fn get_unchecked_mut<K>(xs: &mut [K], index: usize) -> &mut K
-{
+unsafe fn get_unchecked_mut<K>(xs: &mut [K], index: usize) -> &mut K {
debug_assert!(index < xs.len());
xs.get_unchecked_mut(index)
}
impl<K> UnionFind<K>
- where K: IndexType
+where
+ K: IndexType,
{
/// Create a new `UnionFind` of `n` disjoint sets.
- pub fn new(n: usize) -> Self
- {
+ pub fn new(n: usize) -> Self {
let rank = vec![0; n];
let parent = (0..n).map(K::new).collect::<Vec<K>>();
- UnionFind{parent, rank}
+ UnionFind { parent, rank }
}
/// Return the representative for `x`.
///
/// **Panics** if `x` is out of bounds.
- pub fn find(&self, x: K) -> K
- {
+ pub fn find(&self, x: K) -> K {
assert!(x.index() < self.parent.len());
unsafe {
let mut x = x;
@@ -65,7 +61,7 @@
// Use unchecked indexing because we can trust the internal set ids.
let xparent = *get_unchecked(&self.parent, x.index());
if xparent == x {
- break
+ break;
}
x = xparent;
}
@@ -79,16 +75,12 @@
/// datastructure in the process and quicken future lookups.
///
/// **Panics** if `x` is out of bounds.
- pub fn find_mut(&mut self, x: K) -> K
- {
+ pub fn find_mut(&mut self, x: K) -> K {
assert!(x.index() < self.parent.len());
- unsafe {
- self.find_mut_recursive(x)
- }
+ unsafe { self.find_mut_recursive(x) }
}
- unsafe fn find_mut_recursive(&mut self, mut x: K) -> K
- {
+ unsafe fn find_mut_recursive(&mut self, mut x: K) -> K {
let mut parent = *get_unchecked(&self.parent, x.index());
while parent != x {
let grandparent = *get_unchecked(&self.parent, parent.index());
@@ -105,14 +97,12 @@
self.find(x) == self.find(y)
}
-
/// Unify the two sets containing `x` and `y`.
///
/// Return `false` if the sets were already the same, `true` if they were unified.
///
/// **Panics** if `x` or `y` is out of bounds.
- pub fn union(&mut self, x: K, y: K) -> bool
- {
+ pub fn union(&mut self, x: K, y: K) -> bool {
if x == y {
return false;
}
@@ -142,8 +132,7 @@
}
/// Return a vector mapping each element to its representative.
- pub fn into_labeling(mut self) -> Vec<K>
- {
+ pub fn into_labeling(mut self) -> Vec<K> {
// write in the labeling of each element
unsafe {
for ix in 0..self.parent.len() {
diff --git a/src/util.rs b/src/util.rs
index 7cc3445..f4d28d9 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,23 +1,25 @@
-
use std::iter;
pub fn enumerate<I>(iterable: I) -> iter::Enumerate<I::IntoIter>
- where I: IntoIterator
+where
+ I: IntoIterator,
{
iterable.into_iter().enumerate()
}
#[cfg(feature = "serde-1")]
pub fn rev<I>(iterable: I) -> iter::Rev<I::IntoIter>
- where I: IntoIterator,
- I::IntoIter: DoubleEndedIterator
+where
+ I: IntoIterator,
+ I::IntoIter: DoubleEndedIterator,
{
iterable.into_iter().rev()
}
pub fn zip<I, J>(i: I, j: J) -> iter::Zip<I::IntoIter, J::IntoIter>
- where I: IntoIterator,
- J: IntoIterator
+where
+ I: IntoIterator,
+ J: IntoIterator,
{
i.into_iter().zip(j)
}
diff --git a/src/visit/dfsvisit.rs b/src/visit/dfsvisit.rs
index 5ac93c7..3acaf77 100644
--- a/src/visit/dfsvisit.rs
+++ b/src/visit/dfsvisit.rs
@@ -1,5 +1,3 @@
-
-
use crate::visit::IntoNeighbors;
use crate::visit::{VisitMap, Visitable};
@@ -29,13 +27,15 @@
macro_rules! try_control {
($e:expr, $p:stmt) => {
match $e {
- x => if x.should_break() {
- return x;
- } else if x.should_prune() {
- $p
+ x => {
+ if x.should_break() {
+ return x;
+ } else if x.should_prune() {
+ $p
+ }
}
}
- }
+ };
}
/// Control flow for `depth_first_search` callbacks.
@@ -53,7 +53,9 @@
}
impl<B> Control<B> {
- pub fn breaking() -> Control<()> { Control::Break(()) }
+ pub fn breaking() -> Control<()> {
+ Control::Break(())
+ }
/// Get the value in `Control::Break(_)`, if present.
pub fn break_value(self) -> Option<B> {
match self {
@@ -73,17 +75,27 @@
}
impl ControlFlow for () {
- fn continuing() { }
+ fn continuing() {}
#[inline]
- fn should_break(&self) -> bool { false }
+ fn should_break(&self) -> bool {
+ false
+ }
#[inline]
- fn should_prune(&self) -> bool { false }
+ fn should_prune(&self) -> bool {
+ false
+ }
}
impl<B> ControlFlow for Control<B> {
- fn continuing() -> Self { Control::Continue }
+ fn continuing() -> Self {
+ Control::Continue
+ }
fn should_break(&self) -> bool {
- if let Control::Break(_) = *self { true } else { false }
+ if let Control::Break(_) = *self {
+ true
+ } else {
+ false
+ }
}
fn should_prune(&self) -> bool {
match *self {
@@ -94,18 +106,30 @@
}
impl<C: ControlFlow, E> ControlFlow for Result<C, E> {
- fn continuing() -> Self { Ok(C::continuing()) }
+ fn continuing() -> Self {
+ Ok(C::continuing())
+ }
fn should_break(&self) -> bool {
- if let Ok(ref c) = *self { c.should_break() } else { true }
+ if let Ok(ref c) = *self {
+ c.should_break()
+ } else {
+ true
+ }
}
fn should_prune(&self) -> bool {
- if let Ok(ref c) = *self { c.should_prune() } else { false }
+ if let Ok(ref c) = *self {
+ c.should_prune()
+ } else {
+ false
+ }
}
}
/// The default is `Continue`.
impl<B> Default for Control<B> {
- fn default() -> Self { Control::Continue }
+ fn default() -> Self {
+ Control::Continue
+ }
}
/// A recursive depth first search.
@@ -171,40 +195,54 @@
/// assert_eq!(&path, &[n(0), n(2), n(4), n(5)]);
/// ```
pub fn depth_first_search<G, I, F, C>(graph: G, starts: I, mut visitor: F) -> C
- where G: IntoNeighbors + Visitable,
- I: IntoIterator<Item=G::NodeId>,
- F: FnMut(DfsEvent<G::NodeId>) -> C,
- C: ControlFlow,
+where
+ G: IntoNeighbors + Visitable,
+ I: IntoIterator<Item = G::NodeId>,
+ F: FnMut(DfsEvent<G::NodeId>) -> C,
+ C: ControlFlow,
{
let time = &mut Time(0);
let discovered = &mut graph.visit_map();
let finished = &mut graph.visit_map();
for start in starts {
- try_control!(dfs_visitor(graph, start, &mut visitor, discovered, finished, time),
- unreachable!());
+ try_control!(
+ dfs_visitor(graph, start, &mut visitor, discovered, finished, time),
+ unreachable!()
+ );
}
C::continuing()
}
-fn dfs_visitor<G, F, C>(graph: G, u: G::NodeId, visitor: &mut F,
- discovered: &mut G::Map, finished: &mut G::Map,
- time: &mut Time) -> C
- where G: IntoNeighbors + Visitable,
- F: FnMut(DfsEvent<G::NodeId>) -> C,
- C: ControlFlow,
+fn dfs_visitor<G, F, C>(
+ graph: G,
+ u: G::NodeId,
+ visitor: &mut F,
+ discovered: &mut G::Map,
+ finished: &mut G::Map,
+ time: &mut Time,
+) -> C
+where
+ G: IntoNeighbors + Visitable,
+ F: FnMut(DfsEvent<G::NodeId>) -> C,
+ C: ControlFlow,
{
if !discovered.visit(u) {
return C::continuing();
}
'prune: loop {
- try_control!(visitor(DfsEvent::Discover(u, time_post_inc(time))), break 'prune);
+ try_control!(
+ visitor(DfsEvent::Discover(u, time_post_inc(time))),
+ break 'prune
+ );
for v in graph.neighbors(u) {
if !discovered.is_visited(&v) {
try_control!(visitor(DfsEvent::TreeEdge(u, v)), continue);
- try_control!(dfs_visitor(graph, v, visitor, discovered, finished, time),
- unreachable!());
+ try_control!(
+ dfs_visitor(graph, v, visitor, discovered, finished, time),
+ unreachable!()
+ );
} else if !finished.is_visited(&v) {
try_control!(visitor(DfsEvent::BackEdge(u, v)), continue);
} else {
@@ -216,8 +254,10 @@
}
let first_finish = finished.visit(u);
debug_assert!(first_finish);
- try_control!(visitor(DfsEvent::Finish(u, time_post_inc(time))),
- panic!("Pruning on the `DfsEvent::Finish` is not supported!"));
+ try_control!(
+ visitor(DfsEvent::Finish(u, time_post_inc(time))),
+ panic!("Pruning on the `DfsEvent::Finish` is not supported!")
+ );
C::continuing()
}
diff --git a/src/visit/filter.rs b/src/visit/filter.rs
index 7f7c568..866194d 100644
--- a/src/visit/filter.rs
+++ b/src/visit/filter.rs
@@ -1,37 +1,26 @@
-
use crate::prelude::*;
use fixedbitset::FixedBitSet;
use std::collections::HashSet;
use std::marker::PhantomData;
-use crate::visit::{
- GraphBase,
- GraphProp,
- IntoEdgeReferences,
- IntoEdges,
- IntoEdgesDirected,
- IntoNeighbors,
- IntoNeighborsDirected,
- IntoNodeIdentifiers,
- IntoNodeReferences,
- NodeIndexable,
- NodeRef,
- VisitMap,
- Visitable,
-};
+use crate::data::DataMap;
use crate::visit::{Data, NodeCompactIndexable, NodeCount};
-use crate::data::{DataMap};
+use crate::visit::{
+ GraphBase, GraphProp, IntoEdgeReferences, IntoEdges, IntoEdgesDirected, IntoNeighbors,
+ IntoNeighborsDirected, IntoNodeIdentifiers, IntoNodeReferences, NodeIndexable, NodeRef,
+ VisitMap, Visitable,
+};
/// A graph filter for nodes.
-pub trait FilterNode<N>
-{
+pub trait FilterNode<N> {
/// Return true to have the node be part of the graph
fn include_node(&self, node: N) -> bool;
}
impl<F, N> FilterNode<N> for F
- where F: Fn(N) -> bool,
+where
+ F: Fn(N) -> bool,
{
fn include_node(&self, n: N) -> bool {
(*self)(n)
@@ -40,7 +29,8 @@
/// This filter includes the nodes that are contained in the set.
impl<N> FilterNode<N> for FixedBitSet
- where FixedBitSet: VisitMap<N>,
+where
+ FixedBitSet: VisitMap<N>,
{
fn include_node(&self, n: N) -> bool {
self.is_visited(&n)
@@ -49,7 +39,8 @@
/// This filter includes the nodes that are contained in the set.
impl<N, S> FilterNode<N> for HashSet<N, S>
- where HashSet<N, S>: VisitMap<N>,
+where
+ HashSet<N, S>: VisitMap<N>,
{
fn include_node(&self, n: N) -> bool {
self.is_visited(&n)
@@ -61,8 +52,9 @@
pub struct NodeFiltered<G, F>(pub G, pub F);
impl<F, G> NodeFiltered<G, F>
- where G: GraphBase,
- F: Fn(G::NodeId) -> bool,
+where
+ G: GraphBase,
+ F: Fn(G::NodeId) -> bool,
{
/// Create an `NodeFiltered` adaptor from the closure `filter`.
pub fn from_fn(graph: G, filter: F) -> Self {
@@ -70,14 +62,18 @@
}
}
-impl<G, F> GraphBase for NodeFiltered<G, F> where G: GraphBase {
+impl<G, F> GraphBase for NodeFiltered<G, F>
+where
+ G: GraphBase,
+{
type NodeId = G::NodeId;
type EdgeId = G::EdgeId;
}
impl<'a, G, F> IntoNeighbors for &'a NodeFiltered<G, F>
- where G: IntoNeighbors,
- F: FilterNode<G::NodeId>,
+where
+ G: IntoNeighbors,
+ F: FilterNode<G::NodeId>,
{
type Neighbors = NodeFilteredNeighbors<'a, G::Neighbors, F>;
fn neighbors(self, n: G::NodeId) -> Self::Neighbors {
@@ -90,17 +86,17 @@
}
/// A filtered neighbors iterator.
-pub struct NodeFilteredNeighbors<'a, I, F: 'a>
-{
+pub struct NodeFilteredNeighbors<'a, I, F: 'a> {
include_source: bool,
iter: I,
f: &'a F,
}
impl<'a, I, F> Iterator for NodeFilteredNeighbors<'a, I, F>
- where I: Iterator,
- I::Item: Copy,
- F: FilterNode<I::Item>,
+where
+ I: Iterator,
+ I::Item: Copy,
+ F: FilterNode<I::Item>,
{
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
@@ -114,12 +110,12 @@
}
impl<'a, G, F> IntoNeighborsDirected for &'a NodeFiltered<G, F>
- where G: IntoNeighborsDirected,
- F: FilterNode<G::NodeId>,
+where
+ G: IntoNeighborsDirected,
+ F: FilterNode<G::NodeId>,
{
type NeighborsDirected = NodeFilteredNeighbors<'a, G::NeighborsDirected, F>;
- fn neighbors_directed(self, n: G::NodeId, dir: Direction)
- -> Self::NeighborsDirected {
+ fn neighbors_directed(self, n: G::NodeId, dir: Direction) -> Self::NeighborsDirected {
NodeFilteredNeighbors {
include_source: self.1.include_node(n),
iter: self.0.neighbors_directed(n, dir),
@@ -129,8 +125,9 @@
}
impl<'a, G, F> IntoNodeIdentifiers for &'a NodeFiltered<G, F>
- where G: IntoNodeIdentifiers,
- F: FilterNode<G::NodeId>,
+where
+ G: IntoNodeIdentifiers,
+ F: FilterNode<G::NodeId>,
{
type NodeIdentifiers = NodeFilteredNeighbors<'a, G::NodeIdentifiers, F>;
fn node_identifiers(self) -> Self::NodeIdentifiers {
@@ -143,8 +140,9 @@
}
impl<'a, G, F> IntoNodeReferences for &'a NodeFiltered<G, F>
- where G: IntoNodeReferences,
- F: FilterNode<G::NodeId>,
+where
+ G: IntoNodeReferences,
+ F: FilterNode<G::NodeId>,
{
type NodeRef = G::NodeRef;
type NodeReferences = NodeFilteredNodes<'a, G::NodeReferences, F>;
@@ -158,17 +156,17 @@
}
/// A filtered node references iterator.
-pub struct NodeFilteredNodes<'a, I, F: 'a>
-{
+pub struct NodeFilteredNodes<'a, I, F: 'a> {
include_source: bool,
iter: I,
f: &'a F,
}
impl<'a, I, F> Iterator for NodeFilteredNodes<'a, I, F>
- where I: Iterator,
- I::Item: Copy + NodeRef,
- F: FilterNode<<I::Item as NodeRef>::NodeId>,
+where
+ I: Iterator,
+ I::Item: Copy + NodeRef,
+ F: FilterNode<<I::Item as NodeRef>::NodeId>,
{
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
@@ -182,8 +180,9 @@
}
impl<'a, G, F> IntoEdgeReferences for &'a NodeFiltered<G, F>
- where G: IntoEdgeReferences,
- F: FilterNode<G::NodeId>,
+where
+ G: IntoEdgeReferences,
+ F: FilterNode<G::NodeId>,
{
type EdgeRef = G::EdgeRef;
type EdgeReferences = NodeFilteredEdgeReferences<'a, G, G::EdgeReferences, F>;
@@ -197,29 +196,30 @@
}
/// A filtered edges iterator.
-pub struct NodeFilteredEdgeReferences<'a, G, I, F: 'a>
-{
+pub struct NodeFilteredEdgeReferences<'a, G, I, F: 'a> {
graph: PhantomData<G>,
iter: I,
f: &'a F,
}
impl<'a, G, I, F> Iterator for NodeFilteredEdgeReferences<'a, G, I, F>
- where F: FilterNode<G::NodeId>,
- G: IntoEdgeReferences,
- I: Iterator<Item=G::EdgeRef>,
+where
+ F: FilterNode<G::NodeId>,
+ G: IntoEdgeReferences,
+ I: Iterator<Item = G::EdgeRef>,
{
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
let f = self.f;
- self.iter.find(move |&edge| f.include_node(edge.source()) &&
- f.include_node(edge.target()))
+ self.iter
+ .find(move |&edge| f.include_node(edge.source()) && f.include_node(edge.target()))
}
}
impl<'a, G, F> IntoEdges for &'a NodeFiltered<G, F>
- where G: IntoEdges,
- F: FilterNode<G::NodeId>,
+where
+ G: IntoEdges,
+ F: FilterNode<G::NodeId>,
{
type Edges = NodeFilteredEdges<'a, G, G::Edges, F>;
fn edges(self, a: G::NodeId) -> Self::Edges {
@@ -232,21 +232,19 @@
}
}
-
/// A filtered edges iterator.
-pub struct NodeFilteredEdges<'a, G, I, F: 'a>
-{
+pub struct NodeFilteredEdges<'a, G, I, F: 'a> {
graph: PhantomData<G>,
include_source: bool,
iter: I,
f: &'a F,
}
-
impl<'a, G, I, F> Iterator for NodeFilteredEdges<'a, G, I, F>
- where F: FilterNode<G::NodeId>,
- G: IntoEdges,
- I: Iterator<Item=G::EdgeRef>,
+where
+ F: FilterNode<G::NodeId>,
+ G: IntoEdges,
+ I: Iterator<Item = G::EdgeRef>,
{
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
@@ -260,8 +258,9 @@
}
impl<G, F> DataMap for NodeFiltered<G, F>
- where G: DataMap,
- F: FilterNode<G::NodeId>,
+where
+ G: DataMap,
+ F: FilterNode<G::NodeId>,
{
fn node_weight(&self, id: Self::NodeId) -> Option<&Self::NodeWeight> {
if self.1.include_node(id) {
@@ -277,13 +276,15 @@
}
macro_rules! access0 {
- ($e:expr) => ($e.0)
+ ($e:expr) => {
+ $e.0
+ };
}
-Data!{delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
-NodeIndexable!{delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
-GraphProp!{delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
-Visitable!{delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
+Data! {delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
+NodeIndexable! {delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
+GraphProp! {delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
+Visitable! {delegate_impl [[G, F], G, NodeFiltered<G, F>, access0]}
/// A graph filter for edges
pub trait FilterEdge<Edge> {
@@ -292,7 +293,8 @@
}
impl<F, N> FilterEdge<N> for F
- where F: Fn(N) -> bool,
+where
+ F: Fn(N) -> bool,
{
fn include_edge(&self, n: N) -> bool {
(*self)(n)
@@ -311,8 +313,9 @@
pub struct EdgeFiltered<G, F>(pub G, pub F);
impl<F, G> EdgeFiltered<G, F>
- where G: IntoEdgeReferences,
- F: Fn(G::EdgeRef) -> bool,
+where
+ G: IntoEdgeReferences,
+ F: Fn(G::EdgeRef) -> bool,
{
/// Create an `EdgeFiltered` adaptor from the closure `filter`.
pub fn from_fn(graph: G, filter: F) -> Self {
@@ -320,14 +323,18 @@
}
}
-impl<G, F> GraphBase for EdgeFiltered<G, F> where G: GraphBase {
+impl<G, F> GraphBase for EdgeFiltered<G, F>
+where
+ G: GraphBase,
+{
type NodeId = G::NodeId;
type EdgeId = G::EdgeId;
}
impl<'a, G, F> IntoNeighbors for &'a EdgeFiltered<G, F>
- where G: IntoEdges,
- F: FilterEdge<G::EdgeRef>,
+where
+ G: IntoEdges,
+ F: FilterEdge<G::EdgeRef>,
{
type Neighbors = EdgeFilteredNeighbors<'a, G, F>;
fn neighbors(self, n: G::NodeId) -> Self::Neighbors {
@@ -355,30 +362,37 @@
/// A filtered neighbors iterator.
pub struct EdgeFilteredNeighbors<'a, G, F: 'a>
- where G: IntoEdges,
+where
+ G: IntoEdges,
{
iter: G::Edges,
f: &'a F,
}
impl<'a, G, F> Iterator for EdgeFilteredNeighbors<'a, G, F>
- where F: FilterEdge<G::EdgeRef>,
- G: IntoEdges,
+where
+ F: FilterEdge<G::EdgeRef>,
+ G: IntoEdges,
{
type Item = G::NodeId;
fn next(&mut self) -> Option<Self::Item> {
let f = self.f;
- (&mut self.iter).filter_map(move |edge| {
- if f.include_edge(edge) {
- Some(edge.target())
- } else { None }
- }).next()
+ (&mut self.iter)
+ .filter_map(move |edge| {
+ if f.include_edge(edge) {
+ Some(edge.target())
+ } else {
+ None
+ }
+ })
+ .next()
}
}
impl<'a, G, F> IntoEdgeReferences for &'a EdgeFiltered<G, F>
- where G: IntoEdgeReferences,
- F: FilterEdge<G::EdgeRef>,
+where
+ G: IntoEdgeReferences,
+ F: FilterEdge<G::EdgeRef>,
{
type EdgeRef = G::EdgeRef;
type EdgeReferences = EdgeFilteredEdges<'a, G, G::EdgeReferences, F>;
@@ -392,8 +406,9 @@
}
impl<'a, G, F> IntoEdges for &'a EdgeFiltered<G, F>
- where G: IntoEdges,
- F: FilterEdge<G::EdgeRef>,
+where
+ G: IntoEdges,
+ F: FilterEdge<G::EdgeRef>,
{
type Edges = EdgeFilteredEdges<'a, G, G::Edges, F>;
fn edges(self, n: G::NodeId) -> Self::Edges {
@@ -406,17 +421,17 @@
}
/// A filtered edges iterator.
-pub struct EdgeFilteredEdges<'a, G, I, F: 'a>
-{
+pub struct EdgeFilteredEdges<'a, G, I, F: 'a> {
graph: PhantomData<G>,
iter: I,
f: &'a F,
}
impl<'a, G, I, F> Iterator for EdgeFilteredEdges<'a, G, I, F>
- where F: FilterEdge<G::EdgeRef>,
- G: IntoEdgeReferences,
- I: Iterator<Item=G::EdgeRef>,
+where
+ F: FilterEdge<G::EdgeRef>,
+ G: IntoEdgeReferences,
+ I: Iterator<Item = G::EdgeRef>,
{
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
@@ -460,11 +475,11 @@
}
}
-Data!{delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
-GraphProp!{delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
-IntoNodeIdentifiers!{delegate_impl [['a, G, F], G, &'a EdgeFiltered<G, F>, access0]}
-IntoNodeReferences!{delegate_impl [['a, G, F], G, &'a EdgeFiltered<G, F>, access0]}
-NodeCompactIndexable!{delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
-NodeCount!{delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
-NodeIndexable!{delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
-Visitable!{delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
+Data! {delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
+GraphProp! {delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
+IntoNodeIdentifiers! {delegate_impl [['a, G, F], G, &'a EdgeFiltered<G, F>, access0]}
+IntoNodeReferences! {delegate_impl [['a, G, F], G, &'a EdgeFiltered<G, F>, access0]}
+NodeCompactIndexable! {delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
+NodeCount! {delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
+NodeIndexable! {delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
+Visitable! {delegate_impl [[G, F], G, EdgeFiltered<G, F>, access0]}
diff --git a/src/visit/macros.rs b/src/visit/macros.rs
index da24542..c558b6e 100644
--- a/src/visit/macros.rs
+++ b/src/visit/macros.rs
@@ -1,4 +1,3 @@
-
/// Define a trait as usual, and a macro that can be used to instantiate
/// implementations of it.
///
@@ -17,7 +16,7 @@
}
}
- remove_sections! { []
+ remove_sections! { []
$(#[$doc])*
pub trait $name $($methods)*
@@ -67,10 +66,14 @@
}
macro_rules! deref {
- ($e:expr) => (*$e);
+ ($e:expr) => {
+ *$e
+ };
}
macro_rules! deref_twice {
- ($e:expr) => (**$e);
+ ($e:expr) => {
+ **$e
+ };
}
/// Implement a trait by delegation. By default as if we are delegating
@@ -130,4 +133,3 @@
}
}
}
-
diff --git a/src/visit/mod.rs b/src/visit/mod.rs
index 739ab58..aa93c35 100644
--- a/src/visit/mod.rs
+++ b/src/visit/mod.rs
@@ -42,7 +42,8 @@
pub use self::filter::*;
pub use self::reversed::*;
-#[macro_use] mod macros;
+#[macro_use]
+mod macros;
mod dfsvisit;
mod traversal;
@@ -50,36 +51,26 @@
pub use self::traversal::*;
use fixedbitset::FixedBitSet;
-use std::collections::{
- HashSet,
-};
-use std::hash::{Hash, BuildHasher};
+use std::collections::HashSet;
+use std::hash::{BuildHasher, Hash};
-use crate::prelude::{Graph, Direction};
+use super::{graph, EdgeType};
+use crate::graph::NodeIndex;
#[cfg(feature = "graphmap")]
use crate::prelude::GraphMap;
#[cfg(feature = "stable_graph")]
use crate::prelude::StableGraph;
-use crate::graph::{NodeIndex};
-use super::{
- graph,
- EdgeType,
-};
+use crate::prelude::{Direction, Graph};
-use crate::graph::{
- IndexType,
-};
+use crate::graph::Frozen;
+use crate::graph::IndexType;
#[cfg(feature = "stable_graph")]
use crate::stable_graph;
-use crate::graph::Frozen;
#[cfg(feature = "graphmap")]
-use crate::graphmap::{
- self,
- NodeTrait,
-};
+use crate::graphmap::{self, NodeTrait};
-trait_template!{
+trait_template! {
/// Base graph trait: defines the associated node identifier and
/// edge identifier types.
pub trait GraphBase {
@@ -94,23 +85,27 @@
}
}
-GraphBase!{delegate_impl []}
-GraphBase!{delegate_impl [['a, G], G, &'a mut G, deref]}
+GraphBase! {delegate_impl []}
+GraphBase! {delegate_impl [['a, G], G, &'a mut G, deref]}
/// A copyable reference to a graph.
-pub trait GraphRef : Copy + GraphBase { }
+pub trait GraphRef: Copy + GraphBase {}
-impl<'a, G> GraphRef for &'a G where G: GraphBase { }
+impl<'a, G> GraphRef for &'a G where G: GraphBase {}
-impl<'a, G> GraphBase for Frozen<'a, G> where G: GraphBase {
+impl<'a, G> GraphBase for Frozen<'a, G>
+where
+ G: GraphBase,
+{
type NodeId = G::NodeId;
type EdgeId = G::EdgeId;
}
#[cfg(feature = "stable_graph")]
impl<'a, N, E: 'a, Ty, Ix> IntoNeighbors for &'a StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Neighbors = stable_graph::Neighbors<'a, E, Ix>;
fn neighbors(self, n: Self::NodeId) -> Self::Neighbors {
@@ -118,11 +113,11 @@
}
}
-
#[cfg(feature = "graphmap")]
impl<'a, N: 'a, E, Ty> IntoNeighbors for &'a GraphMap<N, E, Ty>
- where N: Copy + Ord + Hash,
- Ty: EdgeType,
+where
+ N: Copy + Ord + Hash,
+ Ty: EdgeType,
{
type Neighbors = graphmap::Neighbors<'a, N, Ty>;
fn neighbors(self, n: Self::NodeId) -> Self::Neighbors {
@@ -130,7 +125,6 @@
}
}
-
trait_template! {
/// Access to the neighbors of each node
///
@@ -147,7 +141,7 @@
}
}
-IntoNeighbors!{delegate_impl []}
+IntoNeighbors! {delegate_impl []}
trait_template! {
/// Access to the neighbors of each node, through incoming or outgoing edges.
@@ -168,51 +162,51 @@
}
impl<'a, N, E: 'a, Ty, Ix> IntoNeighbors for &'a Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Neighbors = graph::Neighbors<'a, E, Ix>;
- fn neighbors(self, n: graph::NodeIndex<Ix>)
- -> graph::Neighbors<'a, E, Ix>
- {
+ fn neighbors(self, n: graph::NodeIndex<Ix>) -> graph::Neighbors<'a, E, Ix> {
Graph::neighbors(self, n)
}
}
impl<'a, N, E: 'a, Ty, Ix> IntoNeighborsDirected for &'a Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NeighborsDirected = graph::Neighbors<'a, E, Ix>;
- fn neighbors_directed(self, n: graph::NodeIndex<Ix>, d: Direction)
- -> graph::Neighbors<'a, E, Ix>
- {
+ fn neighbors_directed(
+ self,
+ n: graph::NodeIndex<Ix>,
+ d: Direction,
+ ) -> graph::Neighbors<'a, E, Ix> {
Graph::neighbors_directed(self, n, d)
}
}
#[cfg(feature = "stable_graph")]
impl<'a, N, E: 'a, Ty, Ix> IntoNeighborsDirected for &'a StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NeighborsDirected = stable_graph::Neighbors<'a, E, Ix>;
- fn neighbors_directed(self, n: graph::NodeIndex<Ix>, d: Direction)
- -> Self::NeighborsDirected
- {
+ fn neighbors_directed(self, n: graph::NodeIndex<Ix>, d: Direction) -> Self::NeighborsDirected {
StableGraph::neighbors_directed(self, n, d)
}
}
#[cfg(feature = "graphmap")]
impl<'a, N: 'a, E, Ty> IntoNeighborsDirected for &'a GraphMap<N, E, Ty>
- where N: Copy + Ord + Hash,
- Ty: EdgeType,
+where
+ N: Copy + Ord + Hash,
+ Ty: EdgeType,
{
type NeighborsDirected = graphmap::NeighborsDirected<'a, N, Ty>;
- fn neighbors_directed(self, n: N, dir: Direction)
- -> Self::NeighborsDirected
- {
+ fn neighbors_directed(self, n: N, dir: Direction) -> Self::NeighborsDirected {
self.neighbors_directed(n, dir)
}
}
@@ -238,7 +232,7 @@
}
}
-IntoEdges!{delegate_impl []}
+IntoEdges! {delegate_impl []}
trait_template! {
/// Access to all edges of each node, in the specified direction.
@@ -264,7 +258,7 @@
}
}
-IntoEdgesDirected!{delegate_impl []}
+IntoEdgesDirected! {delegate_impl []}
trait_template! {
/// Access to the sequence of the graph’s `NodeId`s.
@@ -276,11 +270,12 @@
}
}
-IntoNodeIdentifiers!{delegate_impl []}
+IntoNodeIdentifiers! {delegate_impl []}
impl<'a, N, E: 'a, Ty, Ix> IntoNodeIdentifiers for &'a Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeIdentifiers = graph::NodeIndices<Ix>;
fn node_identifiers(self) -> graph::NodeIndices<Ix> {
@@ -289,8 +284,9 @@
}
impl<N, E, Ty, Ix> NodeCount for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn node_count(&self) -> usize {
self.node_count()
@@ -299,8 +295,9 @@
#[cfg(feature = "stable_graph")]
impl<'a, N, E: 'a, Ty, Ix> IntoNodeIdentifiers for &'a StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeIdentifiers = stable_graph::NodeIndices<'a, N, Ix>;
fn node_identifiers(self) -> Self::NodeIdentifiers {
@@ -310,15 +307,16 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> NodeCount for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
fn node_count(&self) -> usize {
self.node_count()
}
}
-IntoNeighborsDirected!{delegate_impl []}
+IntoNeighborsDirected! {delegate_impl []}
trait_template! {
/// Define associated data for nodes and edges
@@ -329,13 +327,13 @@
}
}
-Data!{delegate_impl []}
-Data!{delegate_impl [['a, G], G, &'a mut G, deref]}
+Data! {delegate_impl []}
+Data! {delegate_impl [['a, G], G, &'a mut G, deref]}
/// An edge reference.
///
/// Edge references are used by traits `IntoEdges` and `IntoEdgeReferences`.
-pub trait EdgeRef : Copy {
+pub trait EdgeRef: Copy {
type NodeId;
type EdgeId;
type Weight;
@@ -350,20 +348,29 @@
}
impl<'a, N, E> EdgeRef for (N, N, &'a E)
- where N: Copy
+where
+ N: Copy,
{
type NodeId = N;
type EdgeId = (N, N);
type Weight = E;
- fn source(&self) -> N { self.0 }
- fn target(&self) -> N { self.1 }
- fn weight(&self) -> &E { self.2 }
- fn id(&self) -> (N, N) { (self.0, self.1) }
+ fn source(&self) -> N {
+ self.0
+ }
+ fn target(&self) -> N {
+ self.1
+ }
+ fn weight(&self) -> &E {
+ self.2
+ }
+ fn id(&self) -> (N, N) {
+ (self.0, self.1)
+ }
}
/// A node reference.
-pub trait NodeRef : Copy {
+pub trait NodeRef: Copy {
type NodeId;
type Weight;
fn id(&self) -> Self::NodeId;
@@ -381,14 +388,17 @@
}
}
-IntoNodeReferences!{delegate_impl []}
+IntoNodeReferences! {delegate_impl []}
impl<Id> NodeRef for (Id, ())
- where Id: Copy,
+where
+ Id: Copy,
{
type NodeId = Id;
type Weight = ();
- fn id(&self) -> Self::NodeId { self.0 }
+ fn id(&self) -> Self::NodeId {
+ self.0
+ }
fn weight(&self) -> &Self::Weight {
static DUMMY: () = ();
&DUMMY
@@ -396,15 +406,19 @@
}
impl<'a, Id, W> NodeRef for (Id, &'a W)
- where Id: Copy,
+where
+ Id: Copy,
{
type NodeId = Id;
type Weight = W;
- fn id(&self) -> Self::NodeId { self.0 }
- fn weight(&self) -> &Self::Weight { self.1 }
+ fn id(&self) -> Self::NodeId {
+ self.0
+ }
+ fn weight(&self) -> &Self::Weight {
+ self.1
+ }
}
-
trait_template! {
/// Access to the sequence of the graph’s edges
pub trait IntoEdgeReferences : Data + GraphRef {
@@ -417,12 +431,13 @@
}
}
-IntoEdgeReferences!{delegate_impl [] }
+IntoEdgeReferences! {delegate_impl [] }
#[cfg(feature = "graphmap")]
impl<N, E, Ty> Data for GraphMap<N, E, Ty>
- where N: Copy + PartialEq,
- Ty: EdgeType,
+where
+ N: Copy + PartialEq,
+ Ty: EdgeType,
{
type NodeWeight = N;
type EdgeWeight = E;
@@ -442,35 +457,38 @@
}
}
-GraphProp!{delegate_impl []}
+GraphProp! {delegate_impl []}
impl<N, E, Ty, Ix> GraphProp for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgeType = Ty;
}
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> GraphProp for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgeType = Ty;
}
#[cfg(feature = "graphmap")]
impl<N, E, Ty> GraphProp for GraphMap<N, E, Ty>
- where N: NodeTrait,
- Ty: EdgeType,
+where
+ N: NodeTrait,
+ Ty: EdgeType,
{
type EdgeType = Ty;
}
-
impl<'a, N: 'a, E: 'a, Ty, Ix> IntoEdgeReferences for &'a Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type EdgeRef = graph::EdgeReference<'a, E, Ix>;
type EdgeReferences = graph::EdgeReferences<'a, E, Ix>;
@@ -479,8 +497,7 @@
}
}
-
-trait_template!{
+trait_template! {
/// The graph’s `NodeId`s map to indices
pub trait NodeIndexable : GraphBase {
@section self
@@ -494,7 +511,7 @@
}
}
-NodeIndexable!{delegate_impl []}
+NodeIndexable! {delegate_impl []}
trait_template! {
/// A graph with a known node count.
@@ -504,7 +521,7 @@
}
}
-NodeCount!{delegate_impl []}
+NodeCount! {delegate_impl []}
trait_template! {
/// The graph’s `NodeId`s map to indices, in a range without holes.
@@ -514,21 +531,30 @@
pub trait NodeCompactIndexable : NodeIndexable + NodeCount { }
}
-NodeCompactIndexable!{delegate_impl []}
+NodeCompactIndexable! {delegate_impl []}
impl<N, E, Ty, Ix> NodeIndexable for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
- fn node_bound(&self) -> usize { self.node_count() }
- fn to_index(&self, ix: NodeIndex<Ix>) -> usize { ix.index() }
- fn from_index(&self, ix: usize) -> Self::NodeId { NodeIndex::new(ix) }
+ fn node_bound(&self) -> usize {
+ self.node_count()
+ }
+ fn to_index(&self, ix: NodeIndex<Ix>) -> usize {
+ ix.index()
+ }
+ fn from_index(&self, ix: usize) -> Self::NodeId {
+ NodeIndex::new(ix)
+ }
}
impl<N, E, Ty, Ix> NodeCompactIndexable for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
-{ }
+where
+ Ty: EdgeType,
+ Ix: IndexType,
+{
+}
/// A mapping for storing the visited status for NodeId `N`.
pub trait VisitMap<N> {
@@ -542,7 +568,8 @@
}
impl<Ix> VisitMap<graph::NodeIndex<Ix>> for FixedBitSet
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
fn visit(&mut self, x: graph::NodeIndex<Ix>) -> bool {
!self.put(x.index())
@@ -553,7 +580,8 @@
}
impl<Ix> VisitMap<graph::EdgeIndex<Ix>> for FixedBitSet
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
fn visit(&mut self, x: graph::EdgeIndex<Ix>) -> bool {
!self.put(x.index())
@@ -564,7 +592,8 @@
}
impl<Ix> VisitMap<Ix> for FixedBitSet
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
fn visit(&mut self, x: Ix) -> bool {
!self.put(x.index())
@@ -575,8 +604,9 @@
}
impl<N, S> VisitMap<N> for HashSet<N, S>
- where N: Hash + Eq,
- S: BuildHasher,
+where
+ N: Hash + Eq,
+ S: BuildHasher,
{
fn visit(&mut self, x: N) -> bool {
self.insert(x)
@@ -586,7 +616,7 @@
}
}
-trait_template!{
+trait_template! {
/// A graph that can create a map that tracks the visited status of its nodes.
pub trait Visitable : GraphBase {
@section type
@@ -599,21 +629,25 @@
fn reset_map(self: &Self, map: &mut Self::Map) -> ();
}
}
-Visitable!{delegate_impl []}
+Visitable! {delegate_impl []}
impl<N, E, Ty, Ix> GraphBase for Graph<N, E, Ty, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
type NodeId = graph::NodeIndex<Ix>;
type EdgeId = graph::EdgeIndex<Ix>;
}
impl<N, E, Ty, Ix> Visitable for Graph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Map = FixedBitSet;
- fn visit_map(&self) -> FixedBitSet { FixedBitSet::with_capacity(self.node_count()) }
+ fn visit_map(&self) -> FixedBitSet {
+ FixedBitSet::with_capacity(self.node_count())
+ }
fn reset_map(&self, map: &mut Self::Map) {
map.clear();
@@ -623,7 +657,8 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> GraphBase for StableGraph<N, E, Ty, Ix>
- where Ix: IndexType,
+where
+ Ix: IndexType,
{
type NodeId = graph::NodeIndex<Ix>;
type EdgeId = graph::EdgeIndex<Ix>;
@@ -631,8 +666,9 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> Visitable for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type Map = FixedBitSet;
fn visit_map(&self) -> FixedBitSet {
@@ -646,17 +682,18 @@
#[cfg(feature = "stable_graph")]
impl<N, E, Ty, Ix> Data for StableGraph<N, E, Ty, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
type NodeWeight = N;
type EdgeWeight = E;
}
-
#[cfg(feature = "graphmap")]
impl<N, E, Ty> GraphBase for GraphMap<N, E, Ty>
- where N: Copy + PartialEq,
+where
+ N: Copy + PartialEq,
{
type NodeId = N;
type EdgeId = (N, N);
@@ -664,11 +701,14 @@
#[cfg(feature = "graphmap")]
impl<N, E, Ty> Visitable for GraphMap<N, E, Ty>
- where N: Copy + Ord + Hash,
- Ty: EdgeType,
+where
+ N: Copy + Ord + Hash,
+ Ty: EdgeType,
{
type Map = HashSet<N>;
- fn visit_map(&self) -> HashSet<N> { HashSet::with_capacity(self.node_count()) }
+ fn visit_map(&self) -> HashSet<N> {
+ HashSet::with_capacity(self.node_count())
+ }
fn reset_map(&self, map: &mut Self::Map) {
map.clear();
}
@@ -693,18 +733,18 @@
}
}
-
-GetAdjacencyMatrix!{delegate_impl []}
+GetAdjacencyMatrix! {delegate_impl []}
#[cfg(feature = "graphmap")]
/// The `GraphMap` keeps an adjacency matrix internally.
impl<N, E, Ty> GetAdjacencyMatrix for GraphMap<N, E, Ty>
- where N: Copy + Ord + Hash,
- Ty: EdgeType,
+where
+ N: Copy + Ord + Hash,
+ Ty: EdgeType,
{
type AdjMatrix = ();
#[inline]
- fn adjacency_matrix(&self) { }
+ fn adjacency_matrix(&self) {}
#[inline]
fn is_adjacent(&self, _: &(), a: N, b: N) -> bool {
self.contains_edge(a, b)
diff --git a/src/visit/reversed.rs b/src/visit/reversed.rs
index ee5c772..c332c70 100644
--- a/src/visit/reversed.rs
+++ b/src/visit/reversed.rs
@@ -1,26 +1,9 @@
-
-use crate::{
- Direction,
- Incoming,
-};
+use crate::{Direction, Incoming};
use crate::visit::{
- GraphBase,
- GraphRef,
- IntoEdges,
- IntoEdgesDirected,
- IntoNodeIdentifiers,
- IntoNodeReferences,
- IntoNeighbors,
- IntoNeighborsDirected,
- IntoEdgeReferences,
- NodeCompactIndexable,
- NodeCount,
- NodeIndexable,
- Visitable,
- EdgeRef,
- Data,
- GraphProp,
+ Data, EdgeRef, GraphBase, GraphProp, GraphRef, IntoEdgeReferences, IntoEdges,
+ IntoEdgesDirected, IntoNeighbors, IntoNeighborsDirected, IntoNodeIdentifiers,
+ IntoNodeReferences, NodeCompactIndexable, NodeCount, NodeIndexable, Visitable,
};
/// An edge-reversing graph adaptor.
@@ -34,33 +17,33 @@
type EdgeId = G::EdgeId;
}
-impl<G: GraphRef> GraphRef for Reversed<G> { }
+impl<G: GraphRef> GraphRef for Reversed<G> {}
-Data!{delegate_impl [[G], G, Reversed<G>, access0]}
+Data! {delegate_impl [[G], G, Reversed<G>, access0]}
impl<G> IntoNeighbors for Reversed<G>
- where G: IntoNeighborsDirected
+where
+ G: IntoNeighborsDirected,
{
type Neighbors = G::NeighborsDirected;
- fn neighbors(self, n: G::NodeId) -> G::NeighborsDirected
- {
+ fn neighbors(self, n: G::NodeId) -> G::NeighborsDirected {
self.0.neighbors_directed(n, Incoming)
}
}
impl<G> IntoNeighborsDirected for Reversed<G>
- where G: IntoNeighborsDirected
+where
+ G: IntoNeighborsDirected,
{
type NeighborsDirected = G::NeighborsDirected;
- fn neighbors_directed(self, n: G::NodeId, d: Direction)
- -> G::NeighborsDirected
- {
+ fn neighbors_directed(self, n: G::NodeId, d: Direction) -> G::NeighborsDirected {
self.0.neighbors_directed(n, d.opposite())
}
}
impl<G> IntoEdges for Reversed<G>
- where G: IntoEdgesDirected
+where
+ G: IntoEdgesDirected,
{
type Edges = ReversedEdges<G::EdgesDirected>;
fn edges(self, a: Self::NodeId) -> Self::Edges {
@@ -71,7 +54,8 @@
}
impl<G> IntoEdgesDirected for Reversed<G>
- where G: IntoEdgesDirected
+where
+ G: IntoEdgesDirected,
{
type EdgesDirected = ReversedEdges<G::EdgesDirected>;
fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::Edges {
@@ -81,8 +65,7 @@
}
}
-impl<G: Visitable> Visitable for Reversed<G>
-{
+impl<G: Visitable> Visitable for Reversed<G> {
type Map = G::Map;
fn visit_map(&self) -> G::Map {
self.0.visit_map()
@@ -98,7 +81,9 @@
}
impl<I> Iterator for ReversedEdges<I>
- where I: Iterator, I::Item: EdgeRef
+where
+ I: Iterator,
+ I::Item: EdgeRef,
{
type Item = ReversedEdgeReference<I::Item>;
fn next(&mut self) -> Option<Self::Item> {
@@ -112,7 +97,8 @@
/// An edge reference
impl<R> EdgeRef for ReversedEdgeReference<R>
- where R: EdgeRef,
+where
+ R: EdgeRef,
{
type NodeId = R::NodeId;
type EdgeId = R::EdgeId;
@@ -132,7 +118,8 @@
}
impl<G> IntoEdgeReferences for Reversed<G>
- where G: IntoEdgeReferences
+where
+ G: IntoEdgeReferences,
{
type EdgeRef = ReversedEdgeReference<G::EdgeRef>;
type EdgeReferences = ReversedEdgeReferences<G::EdgeReferences>;
@@ -149,8 +136,9 @@
}
impl<I> Iterator for ReversedEdgeReferences<I>
- where I: Iterator,
- I::Item: EdgeRef,
+where
+ I: Iterator,
+ I::Item: EdgeRef,
{
type Item = ReversedEdgeReference<I::Item>;
fn next(&mut self) -> Option<Self::Item> {
@@ -159,14 +147,14 @@
}
macro_rules! access0 {
- ($e:expr) => ($e.0)
+ ($e:expr) => {
+ $e.0
+ };
}
-NodeIndexable!{delegate_impl [[G], G, Reversed<G>, access0]}
-NodeCompactIndexable!{delegate_impl [[G], G, Reversed<G>, access0]}
-IntoNodeIdentifiers!{delegate_impl [[G], G, Reversed<G>, access0]}
-IntoNodeReferences!{delegate_impl [[G], G, Reversed<G>, access0]}
-GraphProp!{delegate_impl [[G], G, Reversed<G>, access0]}
-NodeCount!{delegate_impl [[G], G, Reversed<G>, access0]}
-
-
+NodeIndexable! {delegate_impl [[G], G, Reversed<G>, access0]}
+NodeCompactIndexable! {delegate_impl [[G], G, Reversed<G>, access0]}
+IntoNodeIdentifiers! {delegate_impl [[G], G, Reversed<G>, access0]}
+IntoNodeReferences! {delegate_impl [[G], G, Reversed<G>, access0]}
+GraphProp! {delegate_impl [[G], G, Reversed<G>, access0]}
+NodeCount! {delegate_impl [[G], G, Reversed<G>, access0]}
diff --git a/src/visit/traversal.rs b/src/visit/traversal.rs
index 36618fe..e37f359 100644
--- a/src/visit/traversal.rs
+++ b/src/visit/traversal.rs
@@ -1,7 +1,6 @@
-
-use crate::{Incoming};
-use super::{IntoNeighbors, IntoNeighborsDirected, Visitable, VisitMap};
-use super::{GraphRef, Reversed, IntoNodeIdentifiers};
+use super::{GraphRef, IntoNodeIdentifiers, Reversed};
+use super::{IntoNeighbors, IntoNeighborsDirected, VisitMap, Visitable};
+use crate::Incoming;
use std::collections::VecDeque;
/// Visit nodes of a graph in a depth-first-search (DFS) emitting nodes in
@@ -43,13 +42,15 @@
}
impl<N, VM> Dfs<N, VM>
- where N: Copy + PartialEq,
- VM: VisitMap<N>,
+where
+ N: Copy + PartialEq,
+ VM: VisitMap<N>,
{
/// Create a new **Dfs**, using the graph's visitor map, and put **start**
/// in the stack of nodes to visit.
pub fn new<G>(graph: G, start: N) -> Self
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
let mut dfs = Dfs::empty(graph);
dfs.move_to(start);
@@ -58,15 +59,13 @@
/// Create a `Dfs` from a vector and a visit map
pub fn from_parts(stack: Vec<N>, discovered: VM) -> Self {
- Dfs {
- stack,
- discovered,
- }
+ Dfs { stack, discovered }
}
/// Clear the visit state
pub fn reset<G>(&mut self, graph: G)
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
graph.reset_map(&mut self.discovered);
self.stack.clear();
@@ -74,7 +73,8 @@
/// Create a new **Dfs** using the graph's visitor map, and no stack.
pub fn empty<G>(graph: G) -> Self
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
Dfs {
stack: Vec::new(),
@@ -84,15 +84,15 @@
/// Keep the discovered map, but clear the visit stack and restart
/// the dfs from a particular node.
- pub fn move_to(&mut self, start: N)
- {
+ pub fn move_to(&mut self, start: N) {
self.stack.clear();
self.stack.push(start);
}
/// Return the next node in the dfs, or **None** if the traversal is done.
pub fn next<G>(&mut self, graph: G) -> Option<N>
- where G: IntoNeighbors<NodeId=N>,
+ where
+ G: IntoNeighbors<NodeId = N>,
{
while let Some(node) = self.stack.pop() {
if self.discovered.visit(node) {
@@ -126,13 +126,15 @@
}
impl<N, VM> DfsPostOrder<N, VM>
- where N: Copy + PartialEq,
- VM: VisitMap<N>,
+where
+ N: Copy + PartialEq,
+ VM: VisitMap<N>,
{
/// Create a new `DfsPostOrder` using the graph's visitor map, and put
/// `start` in the stack of nodes to visit.
pub fn new<G>(graph: G, start: N) -> Self
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
let mut dfs = Self::empty(graph);
dfs.move_to(start);
@@ -141,7 +143,8 @@
/// Create a new `DfsPostOrder` using the graph's visitor map, and no stack.
pub fn empty<G>(graph: G) -> Self
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
DfsPostOrder {
stack: Vec::new(),
@@ -152,7 +155,8 @@
/// Clear the visit state
pub fn reset<G>(&mut self, graph: G)
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
graph.reset_map(&mut self.discovered);
graph.reset_map(&mut self.finished);
@@ -161,15 +165,15 @@
/// Keep the discovered and finished map, but clear the visit stack and restart
/// the dfs from a particular node.
- pub fn move_to(&mut self, start: N)
- {
+ pub fn move_to(&mut self, start: N) {
self.stack.clear();
self.stack.push(start);
}
/// Return the next node in the traversal, or `None` if the traversal is done.
pub fn next<G>(&mut self, graph: G) -> Option<N>
- where G: IntoNeighbors<NodeId=N>,
+ where
+ G: IntoNeighbors<NodeId = N>,
{
while let Some(&nx) = self.stack.last() {
if self.discovered.visit(nx) {
@@ -229,27 +233,27 @@
}
impl<N, VM> Bfs<N, VM>
- where N: Copy + PartialEq,
- VM: VisitMap<N>,
+where
+ N: Copy + PartialEq,
+ VM: VisitMap<N>,
{
/// Create a new **Bfs**, using the graph's visitor map, and put **start**
/// in the stack of nodes to visit.
pub fn new<G>(graph: G, start: N) -> Self
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
let mut discovered = graph.visit_map();
discovered.visit(start);
let mut stack = VecDeque::new();
stack.push_front(start);
- Bfs {
- stack,
- discovered,
- }
+ Bfs { stack, discovered }
}
/// Return the next node in the bfs, or **None** if the traversal is done.
pub fn next<G>(&mut self, graph: G) -> Option<N>
- where G: IntoNeighbors<NodeId=N>
+ where
+ G: IntoNeighbors<NodeId = N>,
{
if let Some(node) = self.stack.pop_front() {
for succ in graph.neighbors(node) {
@@ -262,7 +266,6 @@
}
None
}
-
}
/// A topological order traversal for a graph.
@@ -277,13 +280,15 @@
}
impl<N, VM> Topo<N, VM>
- where N: Copy + PartialEq,
- VM: VisitMap<N>,
+where
+ N: Copy + PartialEq,
+ VM: VisitMap<N>,
{
/// Create a new `Topo`, using the graph's visitor map, and put all
/// initial nodes in the to visit list.
pub fn new<G>(graph: G) -> Self
- where G: IntoNodeIdentifiers + IntoNeighborsDirected + Visitable<NodeId=N, Map=VM>,
+ where
+ G: IntoNodeIdentifiers + IntoNeighborsDirected + Visitable<NodeId = N, Map = VM>,
{
let mut topo = Self::empty(graph);
topo.extend_with_initials(graph);
@@ -291,18 +296,22 @@
}
fn extend_with_initials<G>(&mut self, g: G)
- where G: IntoNodeIdentifiers + IntoNeighborsDirected<NodeId=N>,
+ where
+ G: IntoNodeIdentifiers + IntoNeighborsDirected<NodeId = N>,
{
// find all initial nodes (nodes without incoming edges)
- self.tovisit.extend(g.node_identifiers()
- .filter(move |&a| g.neighbors_directed(a, Incoming).next().is_none()));
+ self.tovisit.extend(
+ g.node_identifiers()
+ .filter(move |&a| g.neighbors_directed(a, Incoming).next().is_none()),
+ );
}
/* Private until it has a use */
/// Create a new `Topo`, using the graph's visitor map with *no* starting
/// index specified.
fn empty<G>(graph: G) -> Self
- where G: GraphRef + Visitable<NodeId=N, Map=VM>
+ where
+ G: GraphRef + Visitable<NodeId = N, Map = VM>,
{
Topo {
ordered: graph.visit_map(),
@@ -312,7 +321,8 @@
/// Clear visited state, and put all initial nodes in the to visit list.
pub fn reset<G>(&mut self, graph: G)
- where G: IntoNodeIdentifiers + IntoNeighborsDirected + Visitable<NodeId=N, Map=VM>,
+ where
+ G: IntoNodeIdentifiers + IntoNeighborsDirected + Visitable<NodeId = N, Map = VM>,
{
graph.reset_map(&mut self.ordered);
self.tovisit.clear();
@@ -325,7 +335,8 @@
/// *Note:* The graph may not have a complete topological order, and the only
/// way to know is to run the whole traversal and make sure it visits every node.
pub fn next<G>(&mut self, g: G) -> Option<N>
- where G: IntoNeighborsDirected + Visitable<NodeId=N, Map=VM>,
+ where
+ G: IntoNeighborsDirected + Visitable<NodeId = N, Map = VM>,
{
// Take an unvisited element and find which of its neighbors are next
while let Some(nix) = self.tovisit.pop() {
@@ -336,7 +347,10 @@
for neigh in g.neighbors(nix) {
// Look at each neighbor, and those that only have incoming edges
// from the already ordered list, they are the next to visit.
- if Reversed(g).neighbors(neigh).all(|b| self.ordered.is_visited(&b)) {
+ if Reversed(g)
+ .neighbors(neigh)
+ .all(|b| self.ordered.is_visited(&b))
+ {
self.tovisit.push(neigh);
}
}
@@ -346,7 +360,6 @@
}
}
-
/// A walker is a traversal state, but where part of the traversal
/// information is supplied manually to each next call.
///
@@ -359,8 +372,9 @@
/// Create an iterator out of the walker and given `context`.
fn iter(self, context: Context) -> WalkerIter<Self, Context>
- where Self: Sized,
- Context: Clone,
+ where
+ Self: Sized,
+ Context: Clone,
{
WalkerIter {
walker: self,
@@ -377,8 +391,9 @@
}
impl<W, C> WalkerIter<W, C>
- where W: Walker<C>,
- C: Clone,
+where
+ W: Walker<C>,
+ C: Clone,
{
pub fn context(&self) -> C {
self.context.clone()
@@ -394,8 +409,9 @@
}
impl<W, C> Iterator for WalkerIter<W, C>
- where W: Walker<C>,
- C: Clone,
+where
+ W: Walker<C>,
+ C: Clone,
{
type Item = W::Item;
fn next(&mut self) -> Option<Self::Item> {
@@ -404,7 +420,8 @@
}
impl<'a, C, W: ?Sized> Walker<C> for &'a mut W
- where W: Walker<C>,
+where
+ W: Walker<C>,
{
type Item = W::Item;
fn walk_next(&mut self, context: C) -> Option<Self::Item> {
@@ -413,7 +430,8 @@
}
impl<G> Walker<G> for Dfs<G::NodeId, G::Map>
- where G: IntoNeighbors + Visitable
+where
+ G: IntoNeighbors + Visitable,
{
type Item = G::NodeId;
fn walk_next(&mut self, context: G) -> Option<Self::Item> {
@@ -422,7 +440,8 @@
}
impl<G> Walker<G> for DfsPostOrder<G::NodeId, G::Map>
- where G: IntoNeighbors + Visitable
+where
+ G: IntoNeighbors + Visitable,
{
type Item = G::NodeId;
fn walk_next(&mut self, context: G) -> Option<Self::Item> {
@@ -431,7 +450,8 @@
}
impl<G> Walker<G> for Bfs<G::NodeId, G::Map>
- where G: IntoNeighbors + Visitable
+where
+ G: IntoNeighbors + Visitable,
{
type Item = G::NodeId;
fn walk_next(&mut self, context: G) -> Option<Self::Item> {
@@ -440,7 +460,8 @@
}
impl<G> Walker<G> for Topo<G::NodeId, G::Map>
- where G: IntoNeighborsDirected + Visitable,
+where
+ G: IntoNeighborsDirected + Visitable,
{
type Item = G::NodeId;
fn walk_next(&mut self, context: G) -> Option<Self::Item> {
diff --git a/tests/graph.rs b/tests/graph.rs
index 758007d..a8e4097 100644
--- a/tests/graph.rs
+++ b/tests/graph.rs
@@ -4,56 +4,36 @@
use std::hash::Hash;
use petgraph::prelude::*;
-use petgraph::{
- EdgeType,
-};
+use petgraph::EdgeType;
use petgraph as pg;
use petgraph::algo::{
- dominators,
- has_path_connecting,
- is_cyclic_undirected,
+ dominators, has_path_connecting, is_cyclic_undirected, is_isomorphic_matching,
min_spanning_tree,
- is_isomorphic_matching,
};
use petgraph::graph::node_index as n;
-use petgraph::graph::{
- IndexType,
-};
+use petgraph::graph::IndexType;
+use petgraph::algo::{astar, dijkstra, DfsSpace};
use petgraph::visit::{
- IntoEdges,
- IntoEdgesDirected,
- IntoNodeIdentifiers,
- NodeFiltered,
- Reversed,
- Topo,
- IntoNeighbors,
- VisitMap,
- Walker,
-};
-use petgraph::algo::{
- DfsSpace,
- dijkstra,
- astar,
+ IntoEdges, IntoEdgesDirected, IntoNeighbors, IntoNodeIdentifiers, NodeFiltered, Reversed, Topo,
+ VisitMap, Walker,
};
-use petgraph::dot::{
- Dot,
-};
+use petgraph::dot::Dot;
fn set<I>(iter: I) -> HashSet<I::Item>
- where I: IntoIterator,
- I::Item: Hash + Eq,
+where
+ I: IntoIterator,
+ I::Item: Hash + Eq,
{
iter.into_iter().collect()
}
#[test]
-fn undirected()
-{
+fn undirected() {
let mut og = Graph::new_undirected();
let a = og.add_node(0);
let b = og.add_node(1);
@@ -89,7 +69,6 @@
assert!(og.find_edge(a, a).is_none());
assert!(og.find_edge(b, c).is_some());
assert_graph_consistent(&og);
-
}
#[test]
@@ -147,7 +126,6 @@
}
}
-
#[test]
fn bfs() {
let mut gr = Graph::new();
@@ -187,13 +165,11 @@
assert_eq!(bfs.next(&gr), None);
}
-
-
#[test]
fn mst() {
use petgraph::data::FromElements;
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let a = gr.add_node("A");
let b = gr.add_node("B");
let c = gr.add_node("C");
@@ -245,7 +221,6 @@
assert!(mst.find_edge(d, b).is_none());
assert!(mst.find_edge(b, c).is_none());
-
}
#[test]
@@ -312,7 +287,6 @@
gr.add_edge(a, b, ());
gr.add_edge(a, b, ());
assert_eq!(gr.edge_count(), 2);
-
}
#[test]
@@ -380,8 +354,7 @@
}
#[test]
-fn update_edge()
-{
+fn update_edge() {
{
let mut gr = Graph::new();
let a = gr.add_node("a");
@@ -432,8 +405,17 @@
let scores = dijkstra(&g, a, None, |e| *e.weight());
let mut scores: Vec<_> = scores.into_iter().map(|(n, s)| (g[n], s)).collect();
scores.sort();
- assert_eq!(scores,
- vec![("A", 0), ("B", 7), ("C", 9), ("D", 11), ("E", 20), ("F", 20)]);
+ assert_eq!(
+ scores,
+ vec![
+ ("A", 0),
+ ("B", 7),
+ ("C", 9),
+ ("D", 11),
+ ("E", 20),
+ ("F", 20)
+ ]
+ );
let scores = dijkstra(&g, a, Some(c), |e| *e.weight());
assert_eq!(scores[&c], 9);
@@ -496,7 +478,13 @@
(x2 - x1).abs() + (y2 - y1).abs()
}
};
- let path = astar(&g, a, |finish| finish == f, |e| *e.weight(), heuristic_for(f));
+ let path = astar(
+ &g,
+ a,
+ |finish| finish == f,
+ |e| *e.weight(),
+ heuristic_for(f),
+ );
assert_eq!(path, Some((6., vec![a, d, e, f])));
@@ -504,10 +492,14 @@
let dijkstra_run = dijkstra(&g, a, None, |e| *e.weight());
for end in g.node_indices() {
- let astar_path = astar(&g, a, |finish| finish == end, |e| *e.weight(),
- heuristic_for(end));
- assert_eq!(dijkstra_run.get(&end).cloned(),
- astar_path.map(|t| t.0));
+ let astar_path = astar(
+ &g,
+ a,
+ |finish| finish == end,
+ |e| *e.weight(),
+ heuristic_for(end),
+ );
+ assert_eq!(dijkstra_run.get(&end).cloned(), astar_path.map(|t| t.0));
}
}
@@ -568,20 +560,25 @@
assert_eq!(graphs.len(), 1 << nedges);
// check that all generated graphs have unique adjacency matrices
- let mut adjmats = graphs.iter().map(Graph::adjacency_matrix).collect::<Vec<_>>();
+ let mut adjmats = graphs
+ .iter()
+ .map(Graph::adjacency_matrix)
+ .collect::<Vec<_>>();
adjmats.sort();
adjmats.dedup();
assert_eq!(adjmats.len(), graphs.len());
for gr in &graphs {
- assert!(!petgraph::algo::is_cyclic_directed(gr),
- "Assertion failed: {:?} acyclic", gr);
+ assert!(
+ !petgraph::algo::is_cyclic_directed(gr),
+ "Assertion failed: {:?} acyclic",
+ gr
+ );
}
}
}
#[test]
-fn without()
-{
+fn without() {
let mut og = Graph::new_undirected();
let a = og.add_node(0);
let b = og.add_node(1);
@@ -605,8 +602,7 @@
assert_eq!(term, vec![b, c, d]);
}
-fn assert_is_topo_order<N, E>(gr: &Graph<N, E, Directed>, order: &[NodeIndex])
-{
+fn assert_is_topo_order<N, E>(gr: &Graph<N, E, Directed>, order: &[NodeIndex]) {
assert_eq!(gr.node_count(), order.len());
// check all the edges of the graph
for edge in gr.raw_edges() {
@@ -615,14 +611,18 @@
let ai = order.iter().position(|x| *x == a).unwrap();
let bi = order.iter().position(|x| *x == b).unwrap();
println!("Check that {:?} is before {:?}", a, b);
- assert!(ai < bi, "Topo order: assertion that node {:?} is before {:?} failed",
- a, b);
+ assert!(
+ ai < bi,
+ "Topo order: assertion that node {:?} is before {:?} failed",
+ a,
+ b
+ );
}
}
#[test]
fn test_toposort() {
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let a = gr.add_node("A");
let b = gr.add_node("B");
let c = gr.add_node("C");
@@ -661,7 +661,7 @@
#[test]
fn test_toposort_eq() {
- let mut g = Graph::<_,_>::new();
+ let mut g = Graph::<_, _>::new();
let a = g.add_node("A");
let b = g.add_node("B");
g.add_edge(a, b, ());
@@ -671,7 +671,7 @@
#[test]
fn is_cyclic_directed() {
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let a = gr.add_node("A");
let b = gr.add_node("B");
let c = gr.add_node("C");
@@ -708,8 +708,11 @@
/// Compare two scc sets. Inside each scc, the order does not matter,
/// but the order of the sccs is significant.
-fn assert_sccs_eq(mut res: Vec<Vec<NodeIndex>>, mut answer: Vec<Vec<NodeIndex>>,
- scc_order_matters: bool) {
+fn assert_sccs_eq(
+ mut res: Vec<Vec<NodeIndex>>,
+ mut answer: Vec<Vec<NodeIndex>>,
+ scc_order_matters: bool,
+) {
// normalize the result and compare with the answer.
for scc in &mut res {
scc.sort();
@@ -737,20 +740,28 @@
(7, 5),
(1, 7),
(7, 4),
- (4, 1)]);
+ (4, 1),
+ ]);
- assert_sccs_eq(petgraph::algo::kosaraju_scc(&gr), vec![
- vec![n(0), n(3), n(6)],
- vec![n(2), n(5), n(8)],
- vec![n(1), n(4), n(7)],
- ], true);
+ assert_sccs_eq(
+ petgraph::algo::kosaraju_scc(&gr),
+ vec![
+ vec![n(0), n(3), n(6)],
+ vec![n(2), n(5), n(8)],
+ vec![n(1), n(4), n(7)],
+ ],
+ true,
+ );
// Reversed edges gives the same sccs (when sorted)
- assert_sccs_eq(petgraph::algo::kosaraju_scc(Reversed(&gr)), vec![
- vec![n(1), n(4), n(7)],
- vec![n(2), n(5), n(8)],
- vec![n(0), n(3), n(6)],
- ], true);
-
+ assert_sccs_eq(
+ petgraph::algo::kosaraju_scc(Reversed(&gr)),
+ vec![
+ vec![n(1), n(4), n(7)],
+ vec![n(2), n(5), n(8)],
+ vec![n(0), n(3), n(6)],
+ ],
+ true,
+ );
// Test an undirected graph just for fun.
// Sccs are just connected components.
@@ -759,11 +770,14 @@
let ed = hr.find_edge(n(6), n(8)).unwrap();
assert!(hr.remove_edge(ed).is_some());
- assert_sccs_eq(petgraph::algo::kosaraju_scc(&hr), vec![
- vec![n(0), n(3), n(6)],
- vec![n(1), n(2), n(4), n(5), n(7), n(8)],
- ], false);
-
+ assert_sccs_eq(
+ petgraph::algo::kosaraju_scc(&hr),
+ vec![
+ vec![n(0), n(3), n(6)],
+ vec![n(1), n(2), n(4), n(5), n(7), n(8)],
+ ],
+ false,
+ );
// acyclic non-tree, #14
let n = NodeIndex::new;
@@ -777,27 +791,24 @@
gr.add_edge(n(2), n(0), ());
gr.add_edge(n(1), n(0), ());
- assert_sccs_eq(petgraph::algo::kosaraju_scc(&gr), vec![
- vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)],
- ], true);
+ assert_sccs_eq(
+ petgraph::algo::kosaraju_scc(&gr),
+ vec![vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)]],
+ true,
+ );
// Kosaraju bug from PR #60
let mut gr = Graph::<(), ()>::new();
- gr.extend_with_edges(&[
- (0, 0),
- (1, 0),
- (2, 0),
- (2, 1),
- (2, 2),
- ]);
+ gr.extend_with_edges(&[(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)]);
gr.add_node(());
// no order for the disconnected one
- assert_sccs_eq(petgraph::algo::kosaraju_scc(&gr), vec![
- vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)],
- ], false);
+ assert_sccs_eq(
+ petgraph::algo::kosaraju_scc(&gr),
+ vec![vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)]],
+ false,
+ );
}
-
#[test]
fn tarjan_scc() {
let gr: Graph<(), ()> = Graph::from_edges(&[
@@ -811,14 +822,18 @@
(7, 5),
(1, 7),
(7, 4),
- (4, 1)]);
+ (4, 1),
+ ]);
- assert_sccs_eq(petgraph::algo::tarjan_scc(&gr), vec![
- vec![n(0), n(3), n(6)],
- vec![n(2), n(5), n(8)],
- vec![n(1), n(4), n(7)],
- ], true);
-
+ assert_sccs_eq(
+ petgraph::algo::tarjan_scc(&gr),
+ vec![
+ vec![n(0), n(3), n(6)],
+ vec![n(2), n(5), n(8)],
+ vec![n(1), n(4), n(7)],
+ ],
+ true,
+ );
// Test an undirected graph just for fun.
// Sccs are just connected components.
@@ -827,11 +842,14 @@
let ed = hr.find_edge(n(6), n(8)).unwrap();
assert!(hr.remove_edge(ed).is_some());
- assert_sccs_eq(petgraph::algo::tarjan_scc(&hr), vec![
- vec![n(1), n(2), n(4), n(5), n(7), n(8)],
- vec![n(0), n(3), n(6)],
- ], false);
-
+ assert_sccs_eq(
+ petgraph::algo::tarjan_scc(&hr),
+ vec![
+ vec![n(1), n(2), n(4), n(5), n(7), n(8)],
+ vec![n(0), n(3), n(6)],
+ ],
+ false,
+ );
// acyclic non-tree, #14
let n = NodeIndex::new;
@@ -845,30 +863,26 @@
gr.add_edge(n(2), n(0), ());
gr.add_edge(n(1), n(0), ());
- assert_sccs_eq(petgraph::algo::tarjan_scc(&gr), vec![
- vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)],
- ], true);
+ assert_sccs_eq(
+ petgraph::algo::tarjan_scc(&gr),
+ vec![vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)]],
+ true,
+ );
// Kosaraju bug from PR #60
let mut gr = Graph::<(), ()>::new();
- gr.extend_with_edges(&[
- (0, 0),
- (1, 0),
- (2, 0),
- (2, 1),
- (2, 2),
- ]);
+ gr.extend_with_edges(&[(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)]);
gr.add_node(());
// no order for the disconnected one
- assert_sccs_eq(petgraph::algo::tarjan_scc(&gr), vec![
- vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)],
- ], false);
+ assert_sccs_eq(
+ petgraph::algo::tarjan_scc(&gr),
+ vec![vec![n(0)], vec![n(1)], vec![n(2)], vec![n(3)]],
+ false,
+ );
}
-
#[test]
-fn condensation()
-{
+fn condensation() {
let gr: Graph<(), ()> = Graph::from_edges(&[
(6, 0),
(0, 3),
@@ -881,8 +895,8 @@
(7, 5),
(1, 7),
(7, 4),
- (4, 1)]);
-
+ (4, 1),
+ ]);
// make_acyclic = true
@@ -890,9 +904,11 @@
assert!(cond.node_count() == 3);
assert!(cond.edge_count() == 2);
- assert!(!petgraph::algo::is_cyclic_directed(&cond),
- "Assertion failed: {:?} acyclic", cond);
-
+ assert!(
+ !petgraph::algo::is_cyclic_directed(&cond),
+ "Assertion failed: {:?} acyclic",
+ cond
+ );
// make_acyclic = false
@@ -903,8 +919,7 @@
}
#[test]
-fn connected_comp()
-{
+fn connected_comp() {
let n = NodeIndex::new;
let mut gr = Graph::new();
gr.add_node(0);
@@ -942,8 +957,7 @@
#[should_panic]
#[test]
-fn oob_index()
-{
+fn oob_index() {
let mut gr = Graph::<_, ()>::new();
let a = gr.add_node(0);
let b = gr.add_node(1);
@@ -952,8 +966,7 @@
}
#[test]
-fn usize_index()
-{
+fn usize_index() {
let mut gr = Graph::<_, _, Directed, usize>::with_capacity(0, 0);
let a = gr.add_node(0);
let b = gr.add_node(1);
@@ -968,8 +981,7 @@
}
#[test]
-fn u8_index()
-{
+fn u8_index() {
let mut gr = Graph::<_, (), Undirected, u8>::with_capacity(0, 0);
for _ in 0..255 {
gr.add_node(());
@@ -978,8 +990,7 @@
#[should_panic]
#[test]
-fn u8_index_overflow()
-{
+fn u8_index_overflow() {
let mut gr = Graph::<_, (), Undirected, u8>::with_capacity(0, 0);
for _ in 0..256 {
gr.add_node(());
@@ -988,8 +999,7 @@
#[should_panic]
#[test]
-fn u8_index_overflow_edges()
-{
+fn u8_index_overflow_edges() {
let mut gr = Graph::<_, (), Undirected, u8>::with_capacity(0, 0);
let a = gr.add_node('a');
let b = gr.add_node('b');
@@ -1000,7 +1010,7 @@
#[test]
fn test_weight_iterators() {
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let a = gr.add_node("A");
let b = gr.add_node("B");
let c = gr.add_node("C");
@@ -1044,7 +1054,7 @@
let old = gr.clone();
for (index, ew) in gr.edge_weights_mut().enumerate() {
assert_eq!(old[EdgeIndex::new(index)], *ew);
- *ew = - *ew;
+ *ew = -*ew;
}
for (index, edge) in gr.raw_edges().iter().enumerate() {
assert_eq!(edge.weight, -1. * old[EdgeIndex::new(index)]);
@@ -1053,7 +1063,7 @@
#[test]
fn walk_edges() {
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let a = gr.add_node(0.);
let b = gr.add_node(1.);
let c = gr.add_node(2.);
@@ -1096,7 +1106,7 @@
#[test]
fn index_twice_mut() {
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let a = gr.add_node(0.);
let b = gr.add_node(0.);
let c = gr.add_node(0.);
@@ -1117,7 +1127,9 @@
gr.add_edge(e, g, 9.);
for dir in &[Incoming, Outgoing] {
- for nw in gr.node_weights_mut() { *nw = 0.; }
+ for nw in gr.node_weights_mut() {
+ *nw = 0.;
+ }
// walk the graph and sum incoming edges
let mut dfs = Dfs::new(&gr, a);
@@ -1132,7 +1144,10 @@
// check the sums
for i in 0..gr.node_count() {
let ni = NodeIndex::new(i);
- let s = gr.edges_directed(ni, *dir).map(|e| *e.weight()).fold(0., |a, b| a + b);
+ let s = gr
+ .edges_directed(ni, *dir)
+ .map(|e| *e.weight())
+ .fold(0., |a, b| a + b);
assert_eq!(s, gr[ni]);
}
println!("Sum {:?}: {:?}", dir, gr);
@@ -1169,20 +1184,30 @@
let gr = make_edge_iterator_graph::<Directed>();
for i in gr.node_indices() {
- itertools::assert_equal(
- gr.edges_directed(i, Outgoing),
- gr.edges(i));
+ itertools::assert_equal(gr.edges_directed(i, Outgoing), gr.edges(i));
// Reversed reverses edges, so target and source need to be reversed once more.
itertools::assert_equal(
- gr.edges_directed(i, Outgoing).map(|edge| (edge.source(), edge.target())),
- Reversed(&gr).edges_directed(i, Incoming).map(|edge| (edge.target(), edge.source())));
+ gr.edges_directed(i, Outgoing)
+ .map(|edge| (edge.source(), edge.target())),
+ Reversed(&gr)
+ .edges_directed(i, Incoming)
+ .map(|edge| (edge.target(), edge.source())),
+ );
for edge in gr.edges_directed(i, Outgoing) {
- assert_eq!(edge.source(), i, "outgoing edges should have a fixed source");
+ assert_eq!(
+ edge.source(),
+ i,
+ "outgoing edges should have a fixed source"
+ );
}
for edge in Reversed(&gr).edges_directed(i, Incoming) {
- assert_eq!(edge.target(), i, "reversed incoming edges should have a fixed target");
+ assert_eq!(
+ edge.target(),
+ i,
+ "reversed incoming edges should have a fixed target"
+ );
}
}
@@ -1192,20 +1217,30 @@
println!("{:#?}", gr);
for i in gr.node_indices() {
// Compare against reversed graphs two different ways: using .reverse() and Reversed.
- itertools::assert_equal(
- gr.edges_directed(i, Incoming),
- reversed_gr.edges(i));
+ itertools::assert_equal(gr.edges_directed(i, Incoming), reversed_gr.edges(i));
// Reversed reverses edges, so target and source need to be reversed once more.
itertools::assert_equal(
- gr.edges_directed(i, Incoming).map(|edge| (edge.source(), edge.target())),
- Reversed(&gr).edges(i).map(|edge| (edge.target(), edge.source())));
+ gr.edges_directed(i, Incoming)
+ .map(|edge| (edge.source(), edge.target())),
+ Reversed(&gr)
+ .edges(i)
+ .map(|edge| (edge.target(), edge.source())),
+ );
for edge in gr.edges_directed(i, Incoming) {
- assert_eq!(edge.target(), i, "incoming edges should have a fixed target");
+ assert_eq!(
+ edge.target(),
+ i,
+ "incoming edges should have a fixed target"
+ );
}
for edge in Reversed(&gr).edges_directed(i, Outgoing) {
- assert_eq!(edge.source(), i, "reversed outgoing edges should have a fixed source");
+ assert_eq!(
+ edge.source(),
+ i,
+ "reversed outgoing edges should have a fixed source"
+ );
}
}
}
@@ -1215,38 +1250,58 @@
let gr = make_edge_iterator_graph::<Undirected>();
for i in gr.node_indices() {
- itertools::assert_equal(
- gr.edges_directed(i, Outgoing),
- gr.edges(i));
+ itertools::assert_equal(gr.edges_directed(i, Outgoing), gr.edges(i));
// Reversed reverses edges, so target and source need to be reversed once more.
itertools::assert_equal(
- gr.edges_directed(i, Outgoing).map(|edge| (edge.source(), edge.target())),
- Reversed(&gr).edges_directed(i, Incoming).map(|edge| (edge.target(), edge.source())));
+ gr.edges_directed(i, Outgoing)
+ .map(|edge| (edge.source(), edge.target())),
+ Reversed(&gr)
+ .edges_directed(i, Incoming)
+ .map(|edge| (edge.target(), edge.source())),
+ );
for edge in gr.edges_directed(i, Outgoing) {
- assert_eq!(edge.source(), i, "outgoing edges should have a fixed source");
+ assert_eq!(
+ edge.source(),
+ i,
+ "outgoing edges should have a fixed source"
+ );
}
for edge in Reversed(&gr).edges_directed(i, Incoming) {
- assert_eq!(edge.target(), i, "reversed incoming edges should have a fixed target");
+ assert_eq!(
+ edge.target(),
+ i,
+ "reversed incoming edges should have a fixed target"
+ );
}
}
for i in gr.node_indices() {
- itertools::assert_equal(
- gr.edges_directed(i, Incoming),
- gr.edges(i));
+ itertools::assert_equal(gr.edges_directed(i, Incoming), gr.edges(i));
// Reversed reverses edges, so target and source need to be reversed once more.
itertools::assert_equal(
- gr.edges_directed(i, Incoming).map(|edge| (edge.source(), edge.target())),
- Reversed(&gr).edges(i).map(|edge| (edge.target(), edge.source())));
+ gr.edges_directed(i, Incoming)
+ .map(|edge| (edge.source(), edge.target())),
+ Reversed(&gr)
+ .edges(i)
+ .map(|edge| (edge.target(), edge.source())),
+ );
for edge in gr.edges_directed(i, Incoming) {
- assert_eq!(edge.target(), i, "incoming edges should have a fixed target");
+ assert_eq!(
+ edge.target(),
+ i,
+ "incoming edges should have a fixed target"
+ );
}
for edge in Reversed(&gr).edges_directed(i, Outgoing) {
- assert_eq!(edge.source(), i, "reversed outgoing edges should have a fixed source");
+ assert_eq!(
+ edge.source(),
+ i,
+ "reversed outgoing edges should have a fixed source"
+ );
}
}
}
@@ -1254,7 +1309,7 @@
#[test]
fn toposort_generic() {
// This is a DAG, visit it in order
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let b = gr.add_node(("B", 0.));
let a = gr.add_node(("A", 0.));
let c = gr.add_node(("C", 0.));
@@ -1314,7 +1369,7 @@
#[test]
fn test_has_path() {
// This is a DAG, visit it in order
- let mut gr = Graph::<_,_>::new();
+ let mut gr = Graph::<_, _>::new();
let b = gr.add_node(("B", 0.));
let a = gr.add_node(("A", 0.));
let c = gr.add_node(("C", 0.));
@@ -1376,24 +1431,27 @@
g.add_edge(e, f, 6);
println!("{:?}", g);
- let g2 = g.filter_map(|_, name| Some(*name), |_, &weight| if weight >= 10 {
- Some(weight)
- } else { None });
+ let g2 = g.filter_map(
+ |_, name| Some(*name),
+ |_, &weight| if weight >= 10 { Some(weight) } else { None },
+ );
assert_eq!(g2.edge_count(), 4);
for edge in g2.raw_edges() {
assert!(edge.weight >= 10);
}
- let g3 = g.filter_map(|i, &name| if i == a || i == e { None } else { Some(name) },
- |i, &weight| {
- let (source, target) = g.edge_endpoints(i).unwrap();
- // don't map edges from a removed node
- assert!(source != a);
- assert!(target != a);
- assert!(source != e);
- assert!(target != e);
- Some(weight)
- });
+ let g3 = g.filter_map(
+ |i, &name| if i == a || i == e { None } else { Some(name) },
+ |i, &weight| {
+ let (source, target) = g.edge_endpoints(i).unwrap();
+ // don't map edges from a removed node
+ assert!(source != a);
+ assert!(target != a);
+ assert!(source != e);
+ assert!(target != e);
+ Some(weight)
+ },
+ );
assert_eq!(g3.node_count(), g.node_count() - 2);
assert_eq!(g3.edge_count(), g.edge_count() - 5);
assert_graph_consistent(&g3);
@@ -1410,11 +1468,8 @@
#[test]
fn from_edges() {
let n = NodeIndex::new;
- let gr = Graph::<(), (), Undirected>::from_edges(&[
- (0, 1), (0, 2), (0, 3),
- (1, 2), (1, 3),
- (2, 3),
- ]);
+ let gr =
+ Graph::<(), (), Undirected>::from_edges(&[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
assert_eq!(gr.node_count(), 4);
assert_eq!(gr.edge_count(), 6);
assert_eq!(gr.neighbors(n(0)).count(), 3);
@@ -1434,8 +1489,9 @@
(2, 3, 3),
]);
gr.retain_edges(|mut gr, i| {
- if gr[i] <= 0 { false }
- else {
+ if gr[i] <= 0 {
+ false
+ } else {
gr[i] -= 1;
let (s, t) = gr.edge_endpoints(i).unwrap();
gr[s] += 1;
@@ -1456,30 +1512,30 @@
}
fn assert_graph_consistent<N, E, Ty, Ix>(g: &Graph<N, E, Ty, Ix>)
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
assert_eq!(g.node_count(), g.node_indices().count());
assert_eq!(g.edge_count(), g.edge_indices().count());
for edge in g.raw_edges() {
- assert!(g.find_edge(edge.source(), edge.target()).is_some(),
- "Edge not in graph! {:?} to {:?}", edge.source(), edge.target());
+ assert!(
+ g.find_edge(edge.source(), edge.target()).is_some(),
+ "Edge not in graph! {:?} to {:?}",
+ edge.source(),
+ edge.target()
+ );
}
}
#[test]
fn neighbors_selfloops() {
// Directed graph
- let mut gr = Graph::<_ ,()>::new();
+ let mut gr = Graph::<_, ()>::new();
let a = gr.add_node("a");
let b = gr.add_node("b");
let c = gr.add_node("c");
- gr.extend_with_edges(&[
- (a, a),
- (a, b),
- (c, a),
- (a, a),
- ]);
+ gr.extend_with_edges(&[(a, a), (a, b), (c, a), (a, a)]);
let out_edges = [a, a, b];
let in_edges = [a, a, c];
@@ -1501,19 +1557,25 @@
let mut seen_walk = Vec::new();
let mut walk = gr.neighbors(a).detach();
- while let Some(n) = walk.next_node(&gr) { seen_walk.push(n); }
+ while let Some(n) = walk.next_node(&gr) {
+ seen_walk.push(n);
+ }
seen_walk.sort();
assert_eq!(&seen_walk, &out_edges);
seen_walk.clear();
let mut walk = gr.neighbors_directed(a, Incoming).detach();
- while let Some(n) = walk.next_node(&gr) { seen_walk.push(n); }
+ while let Some(n) = walk.next_node(&gr) {
+ seen_walk.push(n);
+ }
seen_walk.sort();
assert_eq!(&seen_walk, &in_edges);
seen_walk.clear();
let mut walk = gr.neighbors_undirected(a).detach();
- while let Some(n) = walk.next_node(&gr) { seen_walk.push(n); }
+ while let Some(n) = walk.next_node(&gr) {
+ seen_walk.push(n);
+ }
seen_walk.sort();
assert_eq!(&seen_walk, &undir_edges);
@@ -1522,11 +1584,7 @@
let a = gr.add_node("a");
let b = gr.add_node("b");
let c = gr.add_node("c");
- gr.extend_with_edges(&[
- (a, a),
- (a, b),
- (c, a),
- ]);
+ gr.extend_with_edges(&[(a, a), (a, b), (c, a)]);
let out_edges = [a, b, c];
let in_edges = [a, b, c];
@@ -1548,10 +1606,10 @@
assert_eq!(&seen_undir, &undir_edges);
}
-
fn degree<'a, G>(g: G, node: G::NodeId) -> usize
- where G: IntoNeighbors,
- G::NodeId: PartialEq,
+where
+ G: IntoNeighbors,
+ G::NodeId: PartialEq,
{
// self loops count twice
let original_node = node.clone();
@@ -1567,30 +1625,35 @@
fn degree_sequence() {
let mut gr = Graph::<usize, (), Undirected>::from_edges(&[
(0, 1),
- (1, 2), (1, 3),
- (2, 4), (3, 4),
+ (1, 2),
+ (1, 3),
+ (2, 4),
+ (3, 4),
(4, 4),
- (4, 5), (3, 5),
+ (4, 5),
+ (3, 5),
]);
gr.add_node(0); // add isolated node
- let mut degree_sequence = gr.node_indices()
- .map(|i| degree(&gr, i))
- .collect::<Vec<_>>();
+ let mut degree_sequence = gr
+ .node_indices()
+ .map(|i| degree(&gr, i))
+ .collect::<Vec<_>>();
degree_sequence.sort_by(|x, y| Ord::cmp(y, x));
assert_eq!(°ree_sequence, &[5, 3, 3, 2, 2, 1, 0]);
let mut gr = GraphMap::<_, (), Undirected>::from_edges(&[
(0, 1),
- (1, 2), (1, 3),
- (2, 4), (3, 4),
+ (1, 2),
+ (1, 3),
+ (2, 4),
+ (3, 4),
(4, 4),
- (4, 5), (3, 5),
+ (4, 5),
+ (3, 5),
]);
gr.add_node(6); // add isolated node
- let mut degree_sequence = gr.nodes()
- .map(|i| degree(&gr, i))
- .collect::<Vec<_>>();
+ let mut degree_sequence = gr.nodes().map(|i| degree(&gr, i)).collect::<Vec<_>>();
degree_sequence.sort_by(|x, y| Ord::cmp(y, x));
assert_eq!(°ree_sequence, &[5, 3, 3, 2, 2, 1, 0]);
@@ -1613,10 +1676,11 @@
gr.add_edge(b, a, 5);
// neighbors (edges) are in lifo order, if it's a directed graph
- assert_eq!(gr.neighbors(a).collect::<Vec<_>>(),
- vec![c, a, b]);
- assert_eq!(gr.neighbors_directed(a, Incoming).collect::<Vec<_>>(),
- vec![b, c, c, a]);
+ assert_eq!(gr.neighbors(a).collect::<Vec<_>>(), vec![c, a, b]);
+ assert_eq!(
+ gr.neighbors_directed(a, Incoming).collect::<Vec<_>>(),
+ vec![b, c, c, a]
+ );
}
#[test]
@@ -1631,13 +1695,15 @@
let a = gr.add_node(Record { a: 1, b: r"abc\" });
gr.add_edge(a, a, (1, 2));
let dot_output = format!("{:?}", Dot::new(&gr));
- assert_eq!(dot_output,
- // The single \ turns into four \\\\ because of Debug which turns it to \\ and then escaping each \ to \\.
-r#"digraph {
+ assert_eq!(
+ dot_output,
+ // The single \ turns into four \\\\ because of Debug which turns it to \\ and then escaping each \ to \\.
+ r#"digraph {
0 [label="Record { a: 1, b: \"abc\\\\\" }"]
0 -> 0 [label="(1, 2)"]
}
-"#);
+"#
+ );
}
#[test]
@@ -1700,7 +1766,6 @@
}
assert_eq!(set(po), set(vec![a]));
-
let mut g = Graph::new();
let a = g.add_node("A");
let b = g.add_node("B");
@@ -1813,15 +1878,20 @@
#[test]
fn dfs_visit() {
- use petgraph::visit::{Visitable, VisitMap};
- use petgraph::visit::DfsEvent::*;
- use petgraph::visit::{Time, depth_first_search};
use petgraph::visit::Control;
+ use petgraph::visit::DfsEvent::*;
+ use petgraph::visit::{depth_first_search, Time};
+ use petgraph::visit::{VisitMap, Visitable};
let gr: Graph<(), ()> = Graph::from_edges(&[
- (0, 5), (0, 2), (0, 3), (0, 1),
+ (0, 5),
+ (0, 2),
+ (0, 3),
+ (0, 1),
(1, 3),
- (2, 3), (2, 4),
- (4, 0), (4, 5),
+ (2, 3),
+ (2, 4),
+ (4, 0),
+ (4, 5),
]);
let invalid_time = Time(!0);
@@ -1856,7 +1926,10 @@
assert!(discover_time.iter().all(|x| *x != invalid_time));
assert!(finish_time.iter().all(|x| *x != invalid_time));
assert_eq!(edges.len(), gr.edge_count());
- assert_eq!(edges, set(gr.edge_references().map(|e| (e.source(), e.target()))));
+ assert_eq!(
+ edges,
+ set(gr.edge_references().map(|e| (e.source(), e.target())))
+ );
println!("{:?}", discover_time);
println!("{:?}", finish_time);
@@ -1906,23 +1979,15 @@
assert!(ret.break_value().is_none());
}
-
#[test]
fn filtered_post_order() {
use petgraph::visit::NodeFiltered;
- let mut gr: Graph<(), ()> = Graph::from_edges(&[
- (0, 2),
- (1, 2),
- (0, 3),
- (1, 4),
- (2, 4),
- (4, 5),
- (3, 5),
- ]);
+ let mut gr: Graph<(), ()> =
+ Graph::from_edges(&[(0, 2), (1, 2), (0, 3), (1, 4), (2, 4), (4, 5), (3, 5)]);
// map reachable nodes
let mut dfs = Dfs::new(&gr, n(0));
- while let Some(_) = dfs.next(&gr) { }
+ while let Some(_) = dfs.next(&gr) {}
let map = dfs.discovered;
gr.add_edge(n(0), n(1), ());
@@ -1937,39 +2002,78 @@
#[test]
fn filter_elements() {
- use petgraph::data::Element::{Node, Edge};
- use petgraph::data::FromElements;
+ use petgraph::data::Element::{Edge, Node};
use petgraph::data::ElementIterator;
+ use petgraph::data::FromElements;
let elements = vec![
- Node { weight: "A"},
- Node { weight: "B"},
- Node { weight: "C"},
- Node { weight: "D"},
- Node { weight: "E"},
- Node { weight: "F"},
-
- Edge { source: 0, target: 1, weight: 7 },
- Edge { source: 2, target: 0, weight: 9 },
- Edge { source: 0, target: 3, weight: 14 },
- Edge { source: 1, target: 2, weight: 10 },
- Edge { source: 3, target: 2, weight: 2 },
- Edge { source: 3, target: 4, weight: 9 },
- Edge { source: 1, target: 5, weight: 15 },
- Edge { source: 2, target: 5, weight: 11 },
- Edge { source: 4, target: 5, weight: 6 },
+ Node { weight: "A" },
+ Node { weight: "B" },
+ Node { weight: "C" },
+ Node { weight: "D" },
+ Node { weight: "E" },
+ Node { weight: "F" },
+ Edge {
+ source: 0,
+ target: 1,
+ weight: 7,
+ },
+ Edge {
+ source: 2,
+ target: 0,
+ weight: 9,
+ },
+ Edge {
+ source: 0,
+ target: 3,
+ weight: 14,
+ },
+ Edge {
+ source: 1,
+ target: 2,
+ weight: 10,
+ },
+ Edge {
+ source: 3,
+ target: 2,
+ weight: 2,
+ },
+ Edge {
+ source: 3,
+ target: 4,
+ weight: 9,
+ },
+ Edge {
+ source: 1,
+ target: 5,
+ weight: 15,
+ },
+ Edge {
+ source: 2,
+ target: 5,
+ weight: 11,
+ },
+ Edge {
+ source: 4,
+ target: 5,
+ weight: 6,
+ },
];
let mut g = DiGraph::<_, _>::from_elements(elements.iter().cloned());
println!("{:#?}", g);
assert!(g.contains_edge(n(1), n(5)));
- let g2 = DiGraph::<_, _>::from_elements(elements.iter().cloned().filter_elements(|elt| {
- match elt {
+ let g2 =
+ DiGraph::<_, _>::from_elements(elements.iter().cloned().filter_elements(|elt| match elt {
Node { ref weight } if **weight == "B" => false,
_ => true,
- }
- }));
+ }));
println!("{:#?}", g2);
g.remove_node(n(1));
- assert!(is_isomorphic_matching(&g, &g2, PartialEq::eq, PartialEq::eq));
+ assert!(is_isomorphic_matching(
+ &g,
+ &g2,
+ PartialEq::eq,
+ PartialEq::eq
+ ));
}
#[test]
@@ -1979,29 +2083,29 @@
use petgraph::visit::IntoEdgeReferences;
let gr = UnGraph::<(), _>::from_edges(&[
- // cycle
- (0, 1, 7),
- (1, 2, 9),
- (2, 1, 14),
-
- // cycle
- (3, 4, 10),
- (4, 5, 2),
- (5, 3, 9),
-
- // cross edges
- (0, 3, -1),
- (1, 4, -2),
- (2, 5, -3),
+ // cycle
+ (0, 1, 7),
+ (1, 2, 9),
+ (2, 1, 14),
+ // cycle
+ (3, 4, 10),
+ (4, 5, 2),
+ (5, 3, 9),
+ // cross edges
+ (0, 3, -1),
+ (1, 4, -2),
+ (2, 5, -3),
]);
assert_eq!(connected_components(&gr), 1);
let positive_edges = EdgeFiltered::from_fn(&gr, |edge| *edge.weight() >= 0);
assert_eq!(positive_edges.edge_references().count(), 6);
- assert!(positive_edges.edge_references().all(|edge| *edge.weight() >= 0));
+ assert!(positive_edges
+ .edge_references()
+ .all(|edge| *edge.weight() >= 0));
assert_eq!(connected_components(&positive_edges), 2);
let mut dfs = DfsPostOrder::new(&positive_edges, n(0));
- while let Some(_) = dfs.next(&positive_edges) { }
+ while let Some(_) = dfs.next(&positive_edges) {}
let n = n::<u32>;
for node in &[n(0), n(1), n(2)] {
@@ -2116,37 +2220,79 @@
let doms = dominators::simple_fast(&graph, r);
assert_eq!(doms.root(), r);
- assert_eq!(doms.immediate_dominator(r), None,
- "The root node has no idom");
+ assert_eq!(
+ doms.immediate_dominator(r),
+ None,
+ "The root node has no idom"
+ );
- assert_eq!(doms.immediate_dominator(a), Some(r),
- "r is the immediate dominator of a");
- assert_eq!(doms.immediate_dominator(b), Some(r),
- "r is the immediate dominator of b");
- assert_eq!(doms.immediate_dominator(c), Some(r),
- "r is the immediate dominator of c");
- assert_eq!(doms.immediate_dominator(f), Some(c),
- "c is the immediate dominator of f");
- assert_eq!(doms.immediate_dominator(g), Some(c),
- "c is the immediate dominator of g");
- assert_eq!(doms.immediate_dominator(j), Some(g),
- "g is the immediate dominator of j");
- assert_eq!(doms.immediate_dominator(d), Some(r),
- "r is the immediate dominator of d");
- assert_eq!(doms.immediate_dominator(l), Some(d),
- "d is the immediate dominator of l");
- assert_eq!(doms.immediate_dominator(e), Some(r),
- "r is the immediate dominator of e");
- assert_eq!(doms.immediate_dominator(i), Some(r),
- "r is the immediate dominator of i");
- assert_eq!(doms.immediate_dominator(k), Some(r),
- "r is the immediate dominator of k");
- assert_eq!(doms.immediate_dominator(h), Some(r),
- "r is the immediate dominator of h");
+ assert_eq!(
+ doms.immediate_dominator(a),
+ Some(r),
+ "r is the immediate dominator of a"
+ );
+ assert_eq!(
+ doms.immediate_dominator(b),
+ Some(r),
+ "r is the immediate dominator of b"
+ );
+ assert_eq!(
+ doms.immediate_dominator(c),
+ Some(r),
+ "r is the immediate dominator of c"
+ );
+ assert_eq!(
+ doms.immediate_dominator(f),
+ Some(c),
+ "c is the immediate dominator of f"
+ );
+ assert_eq!(
+ doms.immediate_dominator(g),
+ Some(c),
+ "c is the immediate dominator of g"
+ );
+ assert_eq!(
+ doms.immediate_dominator(j),
+ Some(g),
+ "g is the immediate dominator of j"
+ );
+ assert_eq!(
+ doms.immediate_dominator(d),
+ Some(r),
+ "r is the immediate dominator of d"
+ );
+ assert_eq!(
+ doms.immediate_dominator(l),
+ Some(d),
+ "d is the immediate dominator of l"
+ );
+ assert_eq!(
+ doms.immediate_dominator(e),
+ Some(r),
+ "r is the immediate dominator of e"
+ );
+ assert_eq!(
+ doms.immediate_dominator(i),
+ Some(r),
+ "r is the immediate dominator of i"
+ );
+ assert_eq!(
+ doms.immediate_dominator(k),
+ Some(r),
+ "r is the immediate dominator of k"
+ );
+ assert_eq!(
+ doms.immediate_dominator(h),
+ Some(r),
+ "r is the immediate dominator of h"
+ );
let mut graph = graph.clone();
let z = graph.add_node("z");
let doms = dominators::simple_fast(&graph, r);
- assert_eq!(doms.immediate_dominator(z), None,
- "nodes that aren't reachable from the root do not have an idom");
+ assert_eq!(
+ doms.immediate_dominator(z),
+ None,
+ "nodes that aren't reachable from the root do not have an idom"
+ );
}
diff --git a/tests/graphmap.rs b/tests/graphmap.rs
index c8fbeed..6891cf7 100644
--- a/tests/graphmap.rs
+++ b/tests/graphmap.rs
@@ -5,11 +5,11 @@
use std::fmt;
use petgraph::prelude::*;
-use petgraph::visit::{ Walker, };
+use petgraph::visit::Walker;
-use petgraph::algo::{ dijkstra, };
+use petgraph::algo::dijkstra;
-use petgraph::dot::{Dot, Config};
+use petgraph::dot::{Config, Dot};
#[test]
fn simple() {
@@ -47,13 +47,21 @@
let scores = dijkstra(&gr, a, None, |e| *e.weight());
let mut scores: Vec<_> = scores.into_iter().collect();
scores.sort();
- assert_eq!(scores,
- vec![("A", 0), ("B", 7), ("C", 9), ("D", 11), ("E", 20), ("F", 20)]);
+ assert_eq!(
+ scores,
+ vec![
+ ("A", 0),
+ ("B", 7),
+ ("C", 9),
+ ("D", 11),
+ ("E", 20),
+ ("F", 20)
+ ]
+ );
}
#[test]
-fn remov()
-{
+fn remov() {
let mut g = UnGraphMap::new();
g.add_node(1);
g.add_node(2);
@@ -75,8 +83,7 @@
}
#[test]
-fn remove_directed()
-{
+fn remove_directed() {
let mut g = GraphMap::<_, _, Directed>::with_capacity(0, 0);
g.add_edge(1, 2, -1);
println!("{:?}", g);
@@ -118,13 +125,17 @@
{
let mut cnt = 0;
let mut dfs = Dfs::new(&gr, h);
- while let Some(_) = dfs.next(&gr) { cnt += 1; }
+ while let Some(_) = dfs.next(&gr) {
+ cnt += 1;
+ }
assert_eq!(cnt, 4);
}
{
let mut cnt = 0;
let mut dfs = Dfs::new(&gr, z);
- while let Some(_) = dfs.next(&gr) { cnt += 1; }
+ while let Some(_) = dfs.next(&gr) {
+ cnt += 1;
+ }
assert_eq!(cnt, 1);
}
@@ -146,30 +157,28 @@
gr.add_edge(i, k, 4);
let real_edges: HashSet<_> = gr.all_edges().map(|(a, b, &w)| (a, b, w)).collect();
- let expected_edges: HashSet<_> = vec![
- ("H", "I", 1),
- ("H", "J", 2),
- ("I", "J", 3),
- ("I", "K", 4)
- ].into_iter().collect();
+ let expected_edges: HashSet<_> =
+ vec![("H", "I", 1), ("H", "J", 2), ("I", "J", 3), ("I", "K", 4)]
+ .into_iter()
+ .collect();
assert_eq!(real_edges, expected_edges);
}
#[test]
fn from_edges() {
- let gr = GraphMap::<_, _, Undirected>::from_edges(&[
- ("a", "b", 1),
- ("a", "c", 2),
- ("c", "d", 3),
- ]);
+ let gr =
+ GraphMap::<_, _, Undirected>::from_edges(&[("a", "b", 1), ("a", "c", 2), ("c", "d", 3)]);
assert_eq!(gr.node_count(), 4);
assert_eq!(gr.edge_count(), 3);
assert_eq!(gr[("a", "c")], 2);
let gr = GraphMap::<_, (), Undirected>::from_edges(&[
- (0, 1), (0, 2), (0, 3),
- (1, 2), (1, 3),
+ (0, 1),
+ (0, 2),
+ (0, 3),
+ (1, 2),
+ (1, 3),
(2, 3),
]);
assert_eq!(gr.node_count(), 4);
@@ -182,7 +191,6 @@
println!("{:?}", Dot::with_config(&gr, &[Config::EdgeNoLabel]));
}
-
#[test]
fn graphmap_directed() {
//let root = TypedArena::<Node<_>>::new();
@@ -193,15 +201,7 @@
let c = gr.add_node("C");
let d = gr.add_node("D");
let e = gr.add_node("E");
- let edges = [
- (a, b),
- (a, c),
- (a, d),
- (b, c),
- (c, d),
- (d, e),
- (b, b),
- ];
+ let edges = [(a, b), (a, c), (a, d), (b, c), (c, d), (d, e), (b, b)];
gr.extend(&edges);
// Add reverse edges -- ok!
@@ -215,7 +215,8 @@
}
fn assert_sccs_eq<N>(mut res: Vec<Vec<N>>, mut answer: Vec<Vec<N>>)
- where N: Ord + fmt::Debug,
+where
+ N: Ord + fmt::Debug,
{
// normalize the result and compare with the answer.
for scc in &mut res {
@@ -242,13 +243,13 @@
(7, 5, 7),
(1, 7, 8),
(7, 4, 9),
- (4, 1, 10)]);
-
- assert_sccs_eq(petgraph::algo::kosaraju_scc(&gr), vec![
- vec![0, 3, 6],
- vec![1, 4, 7],
- vec![2, 5, 8],
+ (4, 1, 10),
]);
+
+ assert_sccs_eq(
+ petgraph::algo::kosaraju_scc(&gr),
+ vec![vec![0, 3, 6], vec![1, 4, 7], vec![2, 5, 8]],
+ );
}
#[test]
@@ -264,7 +265,8 @@
(7, 5, 7),
(1, 7, 8),
(7, 4, 9),
- (4, 1, 10)]);
+ (4, 1, 10),
+ ]);
let graph: Graph<_, _, _> = gr.clone().into_graph();
println!("{}", Dot::new(&gr));
@@ -283,11 +285,8 @@
#[test]
fn test_all_edges_mut() {
// graph with edge weights equal to in+out
- let mut graph: GraphMap<_, u32, Directed> = GraphMap::from_edges(&[
- (0, 1, 1),
- (1, 2, 3),
- (2, 0, 2),
- ]);
+ let mut graph: GraphMap<_, u32, Directed> =
+ GraphMap::from_edges(&[(0, 1, 1), (1, 2, 3), (2, 0, 2)]);
// change it so edge weight is equal to 2 * (in+out)
for (start, end, weight) in graph.all_edges_mut() {
diff --git a/tests/iso.rs b/tests/iso.rs
index 539e81b..2ddeb52 100644
--- a/tests/iso.rs
+++ b/tests/iso.rs
@@ -3,19 +3,11 @@
use std::fs::File;
use std::io::prelude::*;
+use petgraph::graph::{edge_index, node_index};
use petgraph::prelude::*;
-use petgraph::{
- EdgeType,
-};
-use petgraph::graph::{
- node_index,
- edge_index,
-};
+use petgraph::EdgeType;
-use petgraph::algo::{
- is_isomorphic,
- is_isomorphic_matching,
-};
+use petgraph::algo::{is_isomorphic, is_isomorphic_matching};
/// Petersen A and B are isomorphic
///
@@ -208,16 +200,12 @@
";
/// Parse a text adjacency matrix format into a directed graph
-fn parse_graph<Ty: EdgeType>(s: &str) -> Graph<(), (), Ty>
-{
+fn parse_graph<Ty: EdgeType>(s: &str) -> Graph<(), (), Ty> {
let mut gr = Graph::with_capacity(0, 0);
let s = s.trim();
let lines = s.lines().filter(|l| !l.is_empty());
for (row, line) in lines.enumerate() {
- for (col, word) in line.split(' ')
- .filter(|s| !s.is_empty())
- .enumerate()
- {
+ for (col, word) in line.split(' ').filter(|s| !s.is_empty()).enumerate() {
let has_edge = word.parse::<i32>().unwrap();
assert!(has_edge == 0 || has_edge == 1);
if has_edge == 0 {
@@ -241,11 +229,11 @@
}
/// Parse a file in adjacency matrix format into a directed graph
-fn graph_from_file(path: &str) -> Graph<(), (), Directed>
-{
+fn graph_from_file(path: &str) -> Graph<(), (), Directed> {
let mut f = File::open(path).expect("file not found");
let mut contents = String::new();
- f.read_to_string(&mut contents).expect("failed to read from file");
+ f.read_to_string(&mut contents)
+ .expect("failed to read from file");
parse_graph(&contents)
}
@@ -269,8 +257,7 @@
*/
#[test]
-fn petersen_iso()
-{
+fn petersen_iso() {
// The correct isomorphism is
// 0 => 0, 1 => 3, 2 => 1, 3 => 4, 5 => 2, 6 => 5, 7 => 7, 8 => 6, 9 => 8, 4 => 9
let peta = str_to_digraph(PETERSEN_A);
@@ -286,8 +273,7 @@
}
#[test]
-fn petersen_undir_iso()
-{
+fn petersen_undir_iso() {
// The correct isomorphism is
// 0 => 0, 1 => 3, 2 => 1, 3 => 4, 5 => 2, 6 => 5, 7 => 7, 8 => 6, 9 => 8, 4 => 9
let peta = str_to_digraph(PETERSEN_A);
@@ -297,8 +283,7 @@
}
#[test]
-fn full_iso()
-{
+fn full_iso() {
let a = str_to_graph(FULL_A);
let b = str_to_graph(FULL_B);
@@ -306,8 +291,7 @@
}
#[test]
-fn praust_dir_no_iso()
-{
+fn praust_dir_no_iso() {
let a = str_to_digraph(PRAUST_A);
let b = str_to_digraph(PRAUST_B);
@@ -315,8 +299,7 @@
}
#[test]
-fn praust_undir_no_iso()
-{
+fn praust_undir_no_iso() {
let a = str_to_graph(PRAUST_A);
let b = str_to_graph(PRAUST_B);
@@ -324,8 +307,7 @@
}
#[test]
-fn coxeter_di_iso()
-{
+fn coxeter_di_iso() {
// The correct isomorphism is
let a = str_to_digraph(COXETER_A);
let b = str_to_digraph(COXETER_B);
@@ -333,8 +315,7 @@
}
#[test]
-fn coxeter_undi_iso()
-{
+fn coxeter_undi_iso() {
// The correct isomorphism is
let a = str_to_graph(COXETER_A);
let b = str_to_graph(COXETER_B);
@@ -342,40 +323,35 @@
}
#[test]
-fn g14_dir_not_iso()
-{
+fn g14_dir_not_iso() {
let a = str_to_digraph(G1D);
let b = str_to_digraph(G4D);
assert!(!petgraph::algo::is_isomorphic(&a, &b));
}
#[test]
-fn g14_undir_not_iso()
-{
+fn g14_undir_not_iso() {
let a = str_to_digraph(G1U);
let b = str_to_digraph(G4U);
assert!(!petgraph::algo::is_isomorphic(&a, &b));
}
#[test]
-fn g12_undir_iso()
-{
+fn g12_undir_iso() {
let a = str_to_digraph(G1U);
let b = str_to_digraph(G2U);
assert!(petgraph::algo::is_isomorphic(&a, &b));
}
#[test]
-fn g3_not_iso()
-{
+fn g3_not_iso() {
let a = str_to_digraph(G3_1);
let b = str_to_digraph(G3_2);
assert!(!petgraph::algo::is_isomorphic(&a, &b));
}
#[test]
-fn g8_not_iso()
-{
+fn g8_not_iso() {
let a = str_to_digraph(G8_1);
let b = str_to_digraph(G8_2);
assert_eq!(a.edge_count(), b.edge_count());
@@ -384,8 +360,7 @@
}
#[test]
-fn s12_not_iso()
-{
+fn s12_not_iso() {
let a = str_to_digraph(S1);
let b = str_to_digraph(S2);
assert_eq!(a.edge_count(), b.edge_count());
@@ -394,8 +369,7 @@
}
#[test]
-fn iso1()
-{
+fn iso1() {
let mut g0 = Graph::<_, ()>::new();
let mut g1 = Graph::<_, ()>::new();
assert!(petgraph::algo::is_isomorphic(&g0, &g1));
@@ -418,8 +392,7 @@
}
#[test]
-fn iso2()
-{
+fn iso2() {
let mut g0 = Graph::<_, ()>::new();
let mut g1 = Graph::<_, ()>::new();
@@ -467,19 +440,24 @@
#[test]
fn iso_matching() {
- let g0 = Graph::<(), _>::from_edges(&[
- (0, 0, 1),
- (0, 1, 2),
- (0, 2, 3),
- (1, 2, 4),
- ]);
+ let g0 = Graph::<(), _>::from_edges(&[(0, 0, 1), (0, 1, 2), (0, 2, 3), (1, 2, 4)]);
let mut g1 = g0.clone();
g1[edge_index(0)] = 0;
- assert!(!is_isomorphic_matching(&g0, &g1, |x, y| x == y, |x, y| x == y));
+ assert!(!is_isomorphic_matching(
+ &g0,
+ &g1,
+ |x, y| x == y,
+ |x, y| x == y
+ ));
let mut g2 = g0.clone();
g2[edge_index(1)] = 0;
- assert!(!is_isomorphic_matching(&g0, &g2, |x, y| x == y, |x, y| x == y));
+ assert!(!is_isomorphic_matching(
+ &g0,
+ &g2,
+ |x, y| x == y,
+ |x, y| x == y
+ ));
}
#[test]
@@ -501,27 +479,12 @@
#[should_panic]
#[test]
fn iso_multigraph_failure() {
- let g0 = Graph::<(), ()>::from_edges(&[
- (0, 0),
- (0, 0),
- (0, 1),
- (1, 1),
- (1, 1),
- (1, 0),
- ]);
+ let g0 = Graph::<(), ()>::from_edges(&[(0, 0), (0, 0), (0, 1), (1, 1), (1, 1), (1, 0)]);
- let g1 = Graph::<(), ()>::from_edges(&[
- (0, 0),
- (0, 1),
- (0, 1),
- (1, 1),
- (1, 0),
- (1, 0),
- ]);
+ let g1 = Graph::<(), ()>::from_edges(&[(0, 0), (0, 1), (0, 1), (1, 1), (1, 0), (1, 0)]);
assert!(!is_isomorphic(&g0, &g1));
}
-
/// Isomorphic pair
const COXETER_A: &str = "
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
@@ -588,4 +551,3 @@
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 1 0
";
-
diff --git a/tests/quickcheck.rs b/tests/quickcheck.rs
index 2831a2d..f95eb1c 100644
--- a/tests/quickcheck.rs
+++ b/tests/quickcheck.rs
@@ -1,11 +1,13 @@
-#![cfg(feature="quickcheck")]
-#[macro_use] extern crate quickcheck;
-extern crate rand;
+#![cfg(feature = "quickcheck")]
+#[macro_use]
+extern crate quickcheck;
extern crate petgraph;
-#[macro_use] extern crate defmac;
+extern crate rand;
+#[macro_use]
+extern crate defmac;
-extern crate odds;
extern crate itertools;
+extern crate odds;
mod utils;
@@ -15,45 +17,29 @@
use std::collections::HashSet;
use std::hash::Hash;
-use rand::Rng;
use itertools::assert_equal;
use itertools::cloned;
+use rand::Rng;
-use petgraph::prelude::*;
-use petgraph::{
- EdgeType,
-};
-use petgraph::dot::{Dot, Config};
use petgraph::algo::{
- condensation,
- min_spanning_tree,
- is_cyclic_undirected,
- is_cyclic_directed,
- is_isomorphic,
- is_isomorphic_matching,
- toposort,
- kosaraju_scc,
- tarjan_scc,
- dijkstra,
- bellman_ford,
-};
-use petgraph::visit::{Topo, Reversed};
-use petgraph::visit::{
- IntoNodeReferences,
- IntoEdgeReferences,
- NodeIndexable,
- EdgeRef,
+ bellman_ford, condensation, dijkstra, is_cyclic_directed, is_cyclic_undirected, is_isomorphic,
+ is_isomorphic_matching, kosaraju_scc, min_spanning_tree, tarjan_scc, toposort,
};
use petgraph::data::FromElements;
-use petgraph::graph::{IndexType, node_index, edge_index};
-use petgraph::graphmap::{
- NodeTrait,
-};
+use petgraph::dot::{Config, Dot};
+use petgraph::graph::{edge_index, node_index, IndexType};
+use petgraph::graphmap::NodeTrait;
+use petgraph::prelude::*;
+use petgraph::visit::{EdgeRef, IntoEdgeReferences, IntoNodeReferences, NodeIndexable};
+use petgraph::visit::{Reversed, Topo};
+use petgraph::EdgeType;
fn mst_graph<N, E, Ty, Ix>(g: &Graph<N, E, Ty, Ix>) -> Graph<N, E, Undirected, Ix>
- where Ty: EdgeType,
- Ix: IndexType,
- N: Clone, E: Clone + PartialOrd,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
+ N: Clone,
+ E: Clone + PartialOrd,
{
Graph::from_elements(min_spanning_tree(&g))
}
@@ -101,34 +87,43 @@
}
fn assert_graph_consistent<N, E, Ty, Ix>(g: &Graph<N, E, Ty, Ix>)
- where Ty: EdgeType,
- Ix: IndexType,
+where
+ Ty: EdgeType,
+ Ix: IndexType,
{
assert_eq!(g.node_count(), g.node_indices().count());
assert_eq!(g.edge_count(), g.edge_indices().count());
for edge in g.raw_edges() {
- assert!(g.find_edge(edge.source(), edge.target()).is_some(),
- "Edge not in graph! {:?} to {:?}", edge.source(), edge.target());
+ assert!(
+ g.find_edge(edge.source(), edge.target()).is_some(),
+ "Edge not in graph! {:?} to {:?}",
+ edge.source(),
+ edge.target()
+ );
}
}
#[test]
fn reverse_directed() {
fn prop<Ty: EdgeType>(mut g: Graph<(), (), Ty>) -> bool {
- let node_outdegrees = g.node_indices()
- .map(|i| g.neighbors_directed(i, Outgoing).count())
- .collect::<Vec<_>>();
- let node_indegrees = g.node_indices()
- .map(|i| g.neighbors_directed(i, Incoming).count())
- .collect::<Vec<_>>();
+ let node_outdegrees = g
+ .node_indices()
+ .map(|i| g.neighbors_directed(i, Outgoing).count())
+ .collect::<Vec<_>>();
+ let node_indegrees = g
+ .node_indices()
+ .map(|i| g.neighbors_directed(i, Incoming).count())
+ .collect::<Vec<_>>();
g.reverse();
- let new_outdegrees = g.node_indices()
- .map(|i| g.neighbors_directed(i, Outgoing).count())
- .collect::<Vec<_>>();
- let new_indegrees = g.node_indices()
- .map(|i| g.neighbors_directed(i, Incoming).count())
- .collect::<Vec<_>>();
+ let new_outdegrees = g
+ .node_indices()
+ .map(|i| g.neighbors_directed(i, Outgoing).count())
+ .collect::<Vec<_>>();
+ let new_indegrees = g
+ .node_indices()
+ .map(|i| g.neighbors_directed(i, Incoming).count())
+ .collect::<Vec<_>>();
assert_eq!(node_outdegrees, new_indegrees);
assert_eq!(node_indegrees, new_outdegrees);
assert_graph_consistent(&g);
@@ -160,14 +155,21 @@
assert_eq!(num_pos_post, g.node_count());
// check against filter_map
- let filtered = og.filter_map(|_, w| if *w >= 0 { Some(*w) } else { None },
- |_, w| Some(*w));
+ let filtered = og.filter_map(
+ |_, w| if *w >= 0 { Some(*w) } else { None },
+ |_, w| Some(*w),
+ );
assert_eq!(g.node_count(), filtered.node_count());
/*
println!("Iso of graph with nodes={}, edges={}",
g.node_count(), g.edge_count());
*/
- assert!(is_isomorphic_matching(&filtered, &g, PartialEq::eq, PartialEq::eq));
+ assert!(is_isomorphic_matching(
+ &filtered,
+ &g,
+ PartialEq::eq,
+ PartialEq::eq
+ ));
true
}
@@ -200,7 +202,8 @@
// check against filter_map
let filtered = og.filter_map(
|_, w| Some(*w),
- |_, w| if *w >= 0 { Some(*w) } else { None });
+ |_, w| if *w >= 0 { Some(*w) } else { None },
+ );
assert_eq!(g.node_count(), filtered.node_count());
assert!(is_isomorphic(&filtered, &g));
}
@@ -235,7 +238,8 @@
// check against filter_map
let filtered = og.filter_map(
|_, w| Some(*w),
- |_, w| if *w >= 0 { Some(*w) } else { None });
+ |_, w| if *w >= 0 { Some(*w) } else { None },
+ );
assert_eq!(g.node_count(), filtered.node_count());
}
true
@@ -267,14 +271,17 @@
// Add edges
for i in g.edge_indices() {
let (s, t) = g.edge_endpoints(i).unwrap();
- ng.add_edge(map[s.index()],
- map[t.index()],
- g[i]);
+ ng.add_edge(map[s.index()], map[t.index()], g[i]);
}
if g.node_count() < 20 && g.edge_count() < 50 {
assert!(is_isomorphic(&g, &ng));
}
- assert!(is_isomorphic_matching(&g, &ng, PartialEq::eq, PartialEq::eq));
+ assert!(is_isomorphic_matching(
+ &g,
+ &ng,
+ PartialEq::eq,
+ PartialEq::eq
+ ));
}
true
}
@@ -297,9 +304,19 @@
ng[j] = (g[j] == 0) as i8;
}
if i.index() < g.node_count() || j.index() < g.edge_count() {
- assert!(!is_isomorphic_matching(&g, &ng, PartialEq::eq, PartialEq::eq));
+ assert!(!is_isomorphic_matching(
+ &g,
+ &ng,
+ PartialEq::eq,
+ PartialEq::eq
+ ));
} else {
- assert!(is_isomorphic_matching(&g, &ng, PartialEq::eq, PartialEq::eq));
+ assert!(is_isomorphic_matching(
+ &g,
+ &ng,
+ PartialEq::eq,
+ PartialEq::eq
+ ));
}
true
}
@@ -378,7 +395,12 @@
assert!(g.remove_edge(ex).is_some());
}
//assert_graph_consistent(&g);
- assert!(g.find_edge(a, b).is_none(), "failed to remove edge {:?} from graph {:?}", (a, b), g);
+ assert!(
+ g.find_edge(a, b).is_none(),
+ "failed to remove edge {:?} from graph {:?}",
+ (a, b),
+ g
+ );
assert!(g.neighbors(a).find(|x| *x == b).is_none());
if !g.is_directed() {
assert!(g.find_edge(b, a).is_none());
@@ -392,17 +414,30 @@
}
fn assert_graphmap_consistent<N, E, Ty>(g: &GraphMap<N, E, Ty>)
- where Ty: EdgeType,
- N: NodeTrait + fmt::Debug,
+where
+ Ty: EdgeType,
+ N: NodeTrait + fmt::Debug,
{
for (a, b, _weight) in g.all_edges() {
- assert!(g.contains_edge(a, b),
- "Edge not in graph! {:?} to {:?}", a, b);
- assert!(g.neighbors(a).find(|x| *x == b).is_some(),
- "Edge {:?} not in neighbor list for {:?}", (a, b), a);
+ assert!(
+ g.contains_edge(a, b),
+ "Edge not in graph! {:?} to {:?}",
+ a,
+ b
+ );
+ assert!(
+ g.neighbors(a).find(|x| *x == b).is_some(),
+ "Edge {:?} not in neighbor list for {:?}",
+ (a, b),
+ a
+ );
if !g.is_directed() {
- assert!(g.neighbors(b).find(|x| *x == a).is_some(),
- "Edge {:?} not in neighbor list for {:?}", (b, a), b);
+ assert!(
+ g.neighbors(b).find(|x| *x == a).is_some(),
+ "Edge {:?} not in neighbor list for {:?}",
+ (b, a),
+ b
+ );
}
}
}
@@ -417,9 +452,8 @@
assert_eq!(contains, g.contains_edge(b, a));
}
assert_eq!(g.remove_edge(a, b).is_some(), contains);
- assert!(!g.contains_edge(a, b) &&
- g.neighbors(a).find(|x| *x == b).is_none());
- //(g.is_directed() || g.neighbors(b).find(|x| *x == a).is_none()));
+ assert!(!g.contains_edge(a, b) && g.neighbors(a).find(|x| *x == b).is_none());
+ //(g.is_directed() || g.neighbors(b).find(|x| *x == a).is_none()));
assert!(g.remove_edge(a, b).is_none());
assert_graphmap_consistent(&g);
true
@@ -433,9 +467,9 @@
fn prop(mut g: UnGraphMap<i8, ()>, a: i8, b: i8) -> bool {
assert_eq!(g.contains_edge(a, b), g.add_edge(a, b, ()).is_some());
g.remove_edge(a, b);
- !g.contains_edge(a, b) &&
- g.neighbors(a).find(|x| *x == b).is_none() &&
- g.neighbors(b).find(|x| *x == a).is_none()
+ !g.contains_edge(a, b)
+ && g.neighbors(a).find(|x| *x == b).is_none()
+ && g.neighbors(b).find(|x| *x == a).is_none()
}
quickcheck::quickcheck(prop as fn(_, _, _) -> bool);
}
@@ -481,7 +515,6 @@
}
}
-
quickcheck! {
// Reversed edges gives the same sccs (when sorted)
fn graph_reverse_sccs(g: Graph<(), ()>) -> bool {
@@ -565,17 +598,18 @@
// shrink the graph by splitting it in two by a very
// simple algorithm, just even and odd node indices
- fn shrink(&self) -> Box<dyn Iterator<Item=Self>> {
+ fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
let self_ = self.clone();
Box::new((0..2).filter_map(move |x| {
- let gr = self_.0.filter_map(|i, w| {
- if i.index() % 2 == x {
- Some(w.clone())
- } else {
- None
- }
- },
- |_, w| Some(w.clone())
+ let gr = self_.0.filter_map(
+ |i, w| {
+ if i.index() % 2 == x {
+ Some(w.clone())
+ } else {
+ None
+ }
+ },
+ |_, w| Some(w.clone()),
);
// make sure we shrink
if gr.node_count() < self_.0.node_count() {
@@ -589,7 +623,11 @@
fn is_topo_order<N>(gr: &Graph<N, (), Directed>, order: &[NodeIndex]) -> bool {
if gr.node_count() != order.len() {
- println!("Graph ({}) and count ({}) had different amount of nodes.", gr.node_count(), order.len());
+ println!(
+ "Graph ({}) and count ({}) had different amount of nodes.",
+ gr.node_count(),
+ order.len()
+ );
return false;
}
// check all the edges of the graph
@@ -606,10 +644,13 @@
true
}
-
fn subset_is_topo_order<N>(gr: &Graph<N, (), Directed>, order: &[NodeIndex]) -> bool {
if gr.node_count() < order.len() {
- println!("Graph (len={}) had less nodes than order (len={})", gr.node_count(), order.len());
+ println!(
+ "Graph (len={}) had less nodes than order (len={})",
+ gr.node_count(),
+ order.len()
+ );
return false;
}
// check all the edges of the graph
@@ -711,13 +752,13 @@
}
fn set<I>(iter: I) -> HashSet<I::Item>
- where I: IntoIterator,
- I::Item: Hash + Eq,
+where
+ I: IntoIterator,
+ I::Item: Hash + Eq,
{
iter.into_iter().collect()
}
-
quickcheck! {
fn dfs_visit(gr: Graph<(), ()>, node: usize) -> bool {
use petgraph::visit::{Visitable, VisitMap};
diff --git a/tests/stable_graph.rs b/tests/stable_graph.rs
index 8645865..9ac401e 100644
--- a/tests/stable_graph.rs
+++ b/tests/stable_graph.rs
@@ -1,20 +1,17 @@
#![cfg(feature = "stable_graph")]
-extern crate petgraph;
extern crate itertools;
-#[macro_use] extern crate defmac;
+extern crate petgraph;
+#[macro_use]
+extern crate defmac;
+use itertools::assert_equal;
+use petgraph::algo::{kosaraju_scc, min_spanning_tree, tarjan_scc};
+use petgraph::dot::Dot;
use petgraph::prelude::*;
use petgraph::stable_graph::node_index as n;
+use petgraph::visit::{IntoEdgeReferences, IntoNodeReferences, NodeIndexable};
use petgraph::EdgeType;
-use petgraph::algo::{kosaraju_scc, tarjan_scc, min_spanning_tree};
-use petgraph::visit::{
- NodeIndexable,
- IntoNodeReferences,
- IntoEdgeReferences,
-};
-use petgraph::dot::Dot;
-use itertools::assert_equal;
#[test]
fn node_indices() {
@@ -72,11 +69,15 @@
(6, 0),
(0, 3),
(3, 6),
- (8, 6), (8, 2),
- (2, 5), (5, 8), (7, 5),
+ (8, 6),
+ (8, 2),
+ (2, 5),
+ (5, 8),
+ (7, 5),
(1, 7),
(7, 4),
- (4, 1)]);
+ (4, 1),
+ ]);
// make an identical replacement of n(4) and leave a hole
let x = gr.add_node(());
gr.add_edge(n(7), x, ());
@@ -91,28 +92,34 @@
println!("{:?}", gr);
let x = n(gr.node_bound() - 1);
- assert_sccs_eq(kosaraju_scc(&gr), vec![
- vec![n(0), n(3), n(6)],
- vec![n(1), n(7), x ],
- vec![n(2), n(5), n(8)],
- ]);
+ assert_sccs_eq(
+ kosaraju_scc(&gr),
+ vec![
+ vec![n(0), n(3), n(6)],
+ vec![n(1), n(7), x],
+ vec![n(2), n(5), n(8)],
+ ],
+ );
}
-
#[test]
fn test_tarjan_scc() {
let gr = scc_graph();
let x = n(gr.node_bound() - 1);
- assert_sccs_eq(tarjan_scc(&gr), vec![
- vec![n(0), n(3), n(6)],
- vec![n(1), n(7), x ],
- vec![n(2), n(5), n(8)],
- ]);
+ assert_sccs_eq(
+ tarjan_scc(&gr),
+ vec![
+ vec![n(0), n(3), n(6)],
+ vec![n(1), n(7), x],
+ vec![n(2), n(5), n(8)],
+ ],
+ );
}
fn make_graph<Ty>() -> StableGraph<(), i32, Ty>
- where Ty: EdgeType,
+where
+ Ty: EdgeType,
{
let mut gr = StableGraph::default();
let mut c = 0..;
@@ -129,7 +136,8 @@
(1, 7, e()),
(7, 4, e()),
(8, 6, e()), // parallel edge
- (4, 1, e())]);
+ (4, 1, e()),
+ ]);
// make an identical replacement of n(4) and leave a hole
let x = gr.add_node(());
gr.add_edge(n(7), x, e());
@@ -164,7 +172,10 @@
fn test_edges_undirected() {
let gr = make_graph::<Undirected>();
let x = n(9);
- assert_equal(edges!(gr, x), vec![(x, 16), (x, 14), (n(1), 13), (n(7), 12)]);
+ assert_equal(
+ edges!(gr, x),
+ vec![(x, 16), (x, 14), (n(1), 13), (n(7), 12)],
+ );
assert_equal(edges!(gr, n(0)), vec![(n(3), 1)]);
assert_equal(edges!(gr, n(4)), vec![]);
}
@@ -173,11 +184,13 @@
fn test_edge_iterators_directed() {
let gr = make_graph::<Directed>();
for i in gr.node_indices() {
- itertools::assert_equal(
- gr.edges_directed(i, Outgoing),
- gr.edges(i));
+ itertools::assert_equal(gr.edges_directed(i, Outgoing), gr.edges(i));
for edge in gr.edges_directed(i, Outgoing) {
- assert_eq!(edge.source(), i, "outgoing edges should have a fixed source");
+ assert_eq!(
+ edge.source(),
+ i,
+ "outgoing edges should have a fixed source"
+ );
}
}
let mut incoming = vec![Vec::new(); gr.node_bound()];
@@ -192,9 +205,14 @@
for i in gr.node_indices() {
itertools::assert_equal(
gr.edges_directed(i, Incoming).map(|e| e.source()),
- incoming[i.index()].iter().rev().cloned());
+ incoming[i.index()].iter().rev().cloned(),
+ );
for edge in gr.edges_directed(i, Incoming) {
- assert_eq!(edge.target(), i, "incoming edges should have a fixed target");
+ assert_eq!(
+ edge.target(),
+ i,
+ "incoming edges should have a fixed target"
+ );
}
}
}
@@ -203,25 +221,29 @@
fn test_edge_iterators_undir() {
let gr = make_graph::<Undirected>();
for i in gr.node_indices() {
- itertools::assert_equal(
- gr.edges_directed(i, Outgoing),
- gr.edges(i));
+ itertools::assert_equal(gr.edges_directed(i, Outgoing), gr.edges(i));
for edge in gr.edges_directed(i, Outgoing) {
- assert_eq!(edge.source(), i, "outgoing edges should have a fixed source");
+ assert_eq!(
+ edge.source(),
+ i,
+ "outgoing edges should have a fixed source"
+ );
}
}
for i in gr.node_indices() {
- itertools::assert_equal(
- gr.edges_directed(i, Incoming),
- gr.edges(i));
+ itertools::assert_equal(gr.edges_directed(i, Incoming), gr.edges(i));
for edge in gr.edges_directed(i, Incoming) {
- assert_eq!(edge.target(), i, "incoming edges should have a fixed target");
+ assert_eq!(
+ edge.target(),
+ i,
+ "incoming edges should have a fixed target"
+ );
}
}
}
#[test]
-#[should_panic(expected="is not a node")]
+#[should_panic(expected = "is not a node")]
fn add_edge_vacant() {
let mut g = StableGraph::<_, _>::new();
let a = g.add_node(0);
@@ -232,7 +254,7 @@
}
#[test]
-#[should_panic(expected="is not a node")]
+#[should_panic(expected = "is not a node")]
fn add_edge_oob() {
let mut g = StableGraph::<_, _>::new();
let a = g.add_node(0);
@@ -245,9 +267,7 @@
fn test_node_references() {
let gr = scc_graph();
- itertools::assert_equal(
- gr.node_references().map(|(i, _)| i),
- gr.node_indices());
+ itertools::assert_equal(gr.node_references().map(|(i, _)| i), gr.node_indices());
}
#[test]
@@ -257,40 +277,19 @@
let b = g.add_node(1);
let c = g.add_node(2);
let d = g.add_node(3);
- g.extend_with_edges(&[
- (a, b, 1),
- (a, c, 2),
- (b, c, 3),
- (c, c, 4),
- (a, d, 5),
- ]);
+ g.extend_with_edges(&[(a, b, 1), (a, c, 2), (b, c, 3), (c, c, 4), (a, d, 5)]);
g.remove_node(b);
- itertools::assert_equal(
- g.neighbors(a),
- vec![d, c],
- );
- itertools::assert_equal(
- g.neighbors(c),
- vec![c, a],
- );
- itertools::assert_equal(
- g.neighbors(d),
- vec![a],
- );
+ itertools::assert_equal(g.neighbors(a), vec![d, c]);
+ itertools::assert_equal(g.neighbors(c), vec![c, a]);
+ itertools::assert_equal(g.neighbors(d), vec![a]);
// the node that was removed
- itertools::assert_equal(
- g.neighbors(b),
- vec![],
- );
+ itertools::assert_equal(g.neighbors(b), vec![]);
// remove one more
g.remove_node(c);
- itertools::assert_equal(
- g.neighbors(c),
- vec![],
- );
+ itertools::assert_equal(g.neighbors(c), vec![]);
}
#[test]
@@ -301,14 +300,16 @@
gr.add_edge(a, a, "10");
gr.add_edge(a, b, "20");
let dot_output = format!("{}", Dot::new(&gr));
- assert_eq!(dot_output,
-r#"digraph {
+ assert_eq!(
+ dot_output,
+ r#"digraph {
0 [label="x"]
1 [label="y"]
0 -> 0 [label="10"]
0 -> 1 [label="20"]
}
-"#);
+"#
+ );
}
defmac!(iter_eq a, b => a.eq(b));
@@ -355,8 +356,8 @@
assert!(edges_eq!(gr5, ans));
}
-use petgraph::stable_graph::StableGraph;
use petgraph::data::FromElements;
+use petgraph::stable_graph::StableGraph;
#[test]
fn from_min_spanning_tree() {
@@ -372,5 +373,5 @@
for i in 0..3 {
let _ = g.remove_node(nodes[i]);
}
- let _ = StableGraph::<(),(),Undirected,usize>::from_elements(min_spanning_tree(&g));
+ let _ = StableGraph::<(), (), Undirected, usize>::from_elements(min_spanning_tree(&g));
}
diff --git a/tests/unionfind.rs b/tests/unionfind.rs
index ff8a51f..8b54db7 100644
--- a/tests/unionfind.rs
+++ b/tests/unionfind.rs
@@ -1,9 +1,9 @@
-extern crate rand;
extern crate petgraph;
+extern crate rand;
-use rand::{Rng, thread_rng, ChaChaRng, SeedableRng};
-use std::collections::HashSet;
use petgraph::unionfind::UnionFind;
+use rand::{thread_rng, ChaChaRng, Rng, SeedableRng};
+use std::collections::HashSet;
#[test]
fn uf_test() {
@@ -90,8 +90,7 @@
}
#[test]
-fn labeling()
-{
+fn labeling() {
let mut u = UnionFind::<u32>::new(48);
for i in 0..24 {
u.union(i + 1, i);
diff --git a/tests/utils/mod.rs b/tests/utils/mod.rs
index 09de454..95b9b37 100644
--- a/tests/utils/mod.rs
+++ b/tests/utils/mod.rs
@@ -1,5 +1,3 @@
-
-
mod qc;
pub use self::qc::*;
diff --git a/tests/utils/qc.rs b/tests/utils/qc.rs
index 2715ab1..f335625 100644
--- a/tests/utils/qc.rs
+++ b/tests/utils/qc.rs
@@ -1,4 +1,3 @@
-
use quickcheck::{Arbitrary, Gen, StdGen};
use std::ops::Deref;
@@ -8,19 +7,21 @@
impl<T> Deref for Small<T> {
type Target = T;
- fn deref(&self) -> &T { &self.0 }
+ fn deref(&self) -> &T {
+ &self.0
+ }
}
impl<T> Arbitrary for Small<T>
- where T: Arbitrary
+where
+ T: Arbitrary,
{
fn arbitrary<G: Gen>(g: &mut G) -> Self {
let sz = g.size() / 2;
Small(T::arbitrary(&mut StdGen::new(g, sz)))
}
- fn shrink(&self) -> Box<dyn Iterator<Item=Self>> {
+ fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
Box::new((**self).shrink().map(Small))
}
}
-
