Struct Graph

pub struct Graph<I: Index, NL: Label, EL: Label> {
    pub nodes: Vec<Node<I, NL>>,
    pub edges: Vec<Edge<I, EL>>,
}

A Graph is in principle a owning tuple of Nodes and Edges.

Fields

nodes: Vec<Node<I, NL>>

edges: Vec<Edge<I, EL>>

Implementations

impl<I: Index, NL: Label, EL: Label> Graph<I, NL, EL>

pub fn contains_edge_with_ids(&self, edge: &(I, I)) -> bool

pub fn contains_node_with_id(&self, node: &I) -> bool

pub fn get_node_by_id(&self, idx: &I) -> Option<&Node<I, NL>>

pub fn neighbours(&self, nodeid: &I) -> Vec<Node<I, NL>>

Returns all nodes connected to the given node id

pub fn cleanup_edges(&mut self)

Removes edges that either come from or incident on invalid nodes.

Examples

use graphlang::{Node,Edge,Graph,are_graphs_isomorph};
let mut graph = Graph {
        nodes: vec![ Node::new(0u32, "a"), Node::new(1, "a") ],
        edges: vec![ Edge::new_unlabeled(0, 1), Edge::new_unlabeled(0, 2), Edge::new_unlabeled(2, 3) ] };
let reference = Graph {
        nodes: vec![ Node::new(0u32, "a"), Node::new(1, "a") ],
        edges: vec![ Edge::new_unlabeled(0, 1) ] };

graph.cleanup_edges();
assert_eq!(&reference, &graph );

pub fn insert(&mut self, g: &Self)

Assumes that the mapping between it and the graph is the identity. So Node(1) in g adds Node(1) in self. If this is not desired apply an isomorphism explicitly using translate_copy. If then node already exists it replaces the label.

pub fn remove(&mut self, g: &Self)

Assumes that the mapping between it and the graph is the identity. So Node(1) in g removes Node(1) in self. If this is not desired apply an isomorphism explicitly using translate_copy If then node does not exists it skips it.

pub fn translate(&mut self, g: &Isomorphism<I>) -> bool

Modifies a graph inplace by translating all ids using an isomorphism. If it contains nodes that are not covered by the isomorphism they are not modified, which can lead to invalid graphs. This behaviour should be reconsidered.

pub fn translate_copy(&self, g: &Isomorphism<I>) -> Self

Returns a graph, that gets translated by an isomorphism. If it contains nodes that are not covered by the isomorphism they are not modified, which can lead to invalid graphs. This behaviour should be reconsidered.

impl<I: Index, NL: Label, EL: Label> Graph<I, NL, EL>

pub fn write_dot_to<W: Write>(&self, output: &mut W) -> Result<()>

Write graph using the dot-format to output. It can be easily visualized using graphviz

Examples

use graphlang::Graph;
let graph: Graph<_,_,_> = create_graph_somehow();
let mut f = std::fs::File::create("Example.dot")?;
graph.write_dot_to(&mut f)?;

Errors

…

Trait Implementations

impl<'a, I: Index, NL: Label, EL: Label> Add for &'a Graph<I, NL, EL>

type Output = Graph<I, NL, EL>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<I: Index, NL: Label, EL: Label> Add for Graph<I, NL, EL>

type Output = Graph<I, NL, EL>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<I: Clone + Index, NL: Clone + Label, EL: Clone + Label> Clone for Graph<I, NL, EL>

fn clone(&self) -> Graph<I, NL, EL>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Index, NL: Debug + Label, EL: Debug + Label> Debug for Graph<I, NL, EL>

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

Formats the value using the given formatter.

impl<'de, I, NL, EL> Deserialize<'de> for Graph<I, NL, EL>

where I: Deserialize<'de> + Index, NL: Deserialize<'de> + Label, EL: Deserialize<'de> + Label,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: Index> From<Graph<I, &str, ()>> for Graph<I, String, ()>

fn from(g: Graph<I, &str, ()>) -> Self

Converts to this type from the input type.

impl<'a, I: Index, NL: Label, EL: Label> GraphWalk<'a, Node<I, NL>, Edge<I, EL>> for Graph<I, NL, EL>

fn nodes(&'a self) -> Nodes<'a, Node<I, NL>>

Returns all the nodes in this graph.

fn edges(&'a self) -> Edges<'a, Edge<I, EL>>

Returns all of the edges in this graph.

fn source(&self, e: &Edge<I, EL>) -> Node<I, NL>

The source node for edge.

fn target(&self, e: &Edge<I, EL>) -> Node<I, NL>

The target node for edge.

impl<'a, I: Index, NL: Label, EL: Label> Labeller<'a, Node<I, NL>, Edge<I, EL>> for Graph<I, NL, EL>

fn graph_id(&'a self) -> Id<'a>

Must return a DOT compatible identifier naming the graph.

fn node_id(&'a self, n: &Node<I, NL>) -> Id<'a>

Maps n to a unique identifier with respect to self. The implementer is responsible for ensuring that the returned name is a valid DOT identifier.

fn node_shape(&'a self, _node: &N) -> Option<LabelText<'a>>

Maps n to one of the graphviz shape names. If None is returned, no shape attribute is specified.

fn node_label(&'a self, n: &N) -> LabelText<'a>

Maps n to a label that will be used in the rendered output. The label need not be unique, and may be the empty string; the default is just the output from node_id.

fn edge_label(&'a self, e: &E) -> LabelText<'a>

Maps e to a label that will be used in the rendered output. The label need not be unique, and may be the empty string; the default is in fact the empty string.

fn node_style(&'a self, _n: &N) -> Style

Maps n to a style that will be used in the rendered output.

fn node_color(&'a self, _node: &N) -> Option<LabelText<'a>>

Maps n to one of the graphviz color names. If None is returned, no color attribute is specified.

fn edge_end_arrow(&'a self, _e: &E) -> Arrow

Maps e to arrow style that will be used on the end of an edge. Defaults to default arrow style.

fn edge_start_arrow(&'a self, _e: &E) -> Arrow

Maps e to arrow style that will be used on the end of an edge. Defaults to default arrow style.

fn edge_style(&'a self, _e: &E) -> Style

Maps e to a style that will be used in the rendered output.

fn edge_color(&'a self, _e: &E) -> Option<LabelText<'a>>

Maps e to one of the graphviz color names. If None is returned, no color attribute is specified.

fn kind(&self) -> Kind

The kind of graph, defaults to Kind::Digraph.

impl<I: Index, NL: Label, EL: Label> PartialEq for Graph<I, NL, EL>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I, NL, EL> Serialize for Graph<I, NL, EL>

where I: Serialize + Index, NL: Serialize + Label, EL: Serialize + Label,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, I: Index, NL: Label, EL: Label> Sub<&'a [I]> for &'a Graph<I, NL, EL>

type Output = Graph<I, NL, EL>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a [I]) -> Self::Output

Performs the - operation.

impl<'a, I: Index, NL: Label, EL: Label> Sub for &'a Graph<I, NL, EL>

type Output = Graph<I, NL, EL>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<I: Index, NL: Label, EL: Label> Sub for Graph<I, NL, EL>

type Output = Graph<I, NL, EL>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.