algograph::algorithm::graphviz

Trait DumpInGraphviz

Source 
pub trait DumpInGraphviz
where
    Self: QueryableTaggedGraph + DirectedOrNot,
    Self::LowerGraph: QueryableGraph,
    Self::Vertex: GraphvizLabelForVertex,
    Self::Edge: GraphvizLabelForEdge,
{
    // Provided method
    fn dump_in_graphviz<W>(&self, out: &mut W, graph_name: &str) -> Result<()>
       where W: Write { ... }
}
Expand description

Dumps a directed/undirected graph into graphviz format.

§Examples

use algograph::{
    algorithm::graphviz::*,
    graph::*,
    tagged::*,
};

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
enum Shape {
    Default,
    Rectangle,
}

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
struct ShapedVertex {
    key: usize,
    shape: Shape,
}

impl GraphvizLabelForVertex for ShapedVertex {
    fn label(&self) -> (String, Option<String>) {
        let name = format!("{}", self.key);
        let label = match self.shape {
            Shape::Rectangle => Some("shape=rectangle".to_owned()),
            _ => None,
        };
        (name, label)
    }
}

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
enum Color {
    Default,
    Red,
}

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
struct ColoredEdge {
    src: VertexId,
    snk: VertexId,
    color: Color,
}

impl algograph::tagged::Edge for ColoredEdge {
    fn source(&self) -> VertexId {
        self.src
    }
    fn sink(&self) -> VertexId {
        self.snk
    }
}

impl GraphvizLabelForEdge for ColoredEdge {
    fn label(&self) -> Option<String> {
        match self.color {
            Color::Red => Some("color=red".to_owned()),
            _ => None,
        }
    }
}

// for a directed graph
let mut dg = NaiveTaggedGraph::<ShapedVertex, ColoredEdge>::new();
let v0 = dg.overwrite_vertex(ShapedVertex {
    key: 0,
    shape: Shape::Default,
});
let v1 = dg.overwrite_vertex(ShapedVertex {
    key: 1,
    shape: Shape::Rectangle,
});
let _ = dg.add_edge(ColoredEdge {
    src: v0,
    snk: v1,
    color: Color::Red,
});
let _ = dg.add_edge(ColoredEdge {
    src: v0,
    snk: v0,
    color: Color::Default,
});
let trial = {
    let mut buf = vec![];
    dg.dump_in_graphviz(&mut buf, "trial").unwrap();
    String::from_utf8(buf).unwrap()
};
assert_eq!(
     trial,
     r#"digraph trial {
  0 ;
  1 [shape=rectangle] ;
  0 -> 1 [color=red] ;
  0 -> 0 ;
}
"#);

// for an undirected graph
let mut udg =
    NaiveTaggedGraph::<ShapedVertex, ColoredEdge, undirected::TreeBackedGraph>::new();
let v0 = udg.overwrite_vertex(ShapedVertex {
    key: 0,
    shape: Shape::Default,
});
let v1 = udg.overwrite_vertex(ShapedVertex {
    key: 1,
    shape: Shape::Rectangle,
});
let _ = udg.add_edge(ColoredEdge {
    src: v0,
    snk: v1,
    color: Color::Red,
});
let _ = udg.add_edge(ColoredEdge {
    src: v0,
    snk: v0,
    color: Color::Default,
});
let trial = {
    let mut buf = vec![];
    udg.dump_in_graphviz(&mut buf, "trial").unwrap();
    String::from_utf8(buf).unwrap()
};
println!("{}", trial);
assert_eq!(
    trial,
    r#"graph trial {
  0 ;
  1 [shape=rectangle] ;
  0 -- 1 [color=red] ;
  0 -- 0 ;
}
"#
);

Provided Methods§

Source

fn dump_in_graphviz<W>(&self, out: &mut W, graph_name: &str) -> Result<()>
where W: Write,

Dumps a directed/undirected graph to a std::io::Write object in the graphviz format.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§