#![feature(core, hash, std_misc)]
use std::cmp::Ordering;
use std::hash::{self, Hash};
use std::collections::hash_map::Hasher;
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 ptreq<T>(a: &T, b: &T) -> bool {
a as *const _ == b as *const _
}
impl<'b, T> PartialEq for Ptr<'b, T>
{
fn eq(&self, other: &Ptr<'b, T>) -> bool {
ptreq(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, H: hash::Writer + hash::Hasher> Hash<H> for Ptr<'b, T>
{
fn hash(&self, st: &mut H)
{
let ptr = (self.0) as *const _;
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)
}
}