1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
extern crate fixedbitset as fb;
use std::cmp::Ordering;
use std::hash::{self, Hash};
use std::fmt;
use std::ops::{Deref};
pub use scored::MinScored;
pub use graphmap::GraphMap;
pub use graph::Graph;
pub use self::EdgeDirection::{Outgoing, Incoming};
pub use visit::{
Bfs,
BfsIter,
Dfs,
DfsIter,
};
mod scored;
pub mod algo;
pub mod graphmap;
pub mod graph;
pub mod visit;
pub mod unionfind;
mod isomorphism;
mod dijkstra;
mod traits_graph;
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum EdgeDirection {
Outgoing = 0,
Incoming = 1
}
#[derive(Copy, Clone, Debug)]
pub struct Directed;
#[derive(Copy, Clone, Debug)]
pub struct Undirected;
pub trait EdgeType {
fn is_directed() -> bool;
}
impl EdgeType for Directed {
#[inline]
fn is_directed() -> bool { true }
}
impl EdgeType for Undirected {
#[inline]
fn is_directed() -> bool { false }
}
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 }
}
fn ptr_eq<T>(a: *const T, b: *const T) -> bool {
a == b
}
impl<'b, T> PartialEq for Ptr<'b, T>
{
fn eq(&self, other: &Ptr<'b, T>) -> bool {
ptr_eq(self.0, other.0)
}
}
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>
{
fn cmp(&self, other: &Ptr<'b, T>) -> Ordering {
let a = self.0 as *const _;
let b = other.0 as *const _;
a.cmp(&b)
}
}
impl<'b, T> Deref for Ptr<'b, T> {
type Target = T;
fn deref<'a>(&'a self) -> &'a T {
self.0
}
}
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)
{
let ptr = (self.0) as *const T;
ptr.hash(st)
}
}
impl<'b, T: fmt::Debug> fmt::Debug for Ptr<'b, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}