Struct rs_graph::attributed::Attributed

pub struct Attributed<G, Gx = (), Nx = (), Ex = ()> { /* fields omitted */ }

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Wrapper to attach attributes with a graph.

This is a wrapper struct that adds additional attributes to an arbitrary graph. The type parameters are

• ’Gx` the type of graph attributes.
• ’Nx` the type of node attributes.
• ’Ex` the type of edge attributes.
• ’Ax` the type of biedge attributes.

The attributed graph implements Graph, Digraph and Network if the the wrapped graph does.

Example

use rs_graph::{LinkedListGraph, classes, traits::*};
use rs_graph::attributed::{Attributes, Attributed, AttributedGraph};

#[derive(Default)]
struct NodeAttr {
    balance: f64,
}

#[derive(Default)]
struct EdgeAttr {
    flow: f64,
}

type MyGraph = Attributed<LinkedListGraph, (), NodeAttr, EdgeAttr>;
let mut g: MyGraph = classes::complete_bipartite(3,4);

{
    let (g, mut attr) = g.split();
    for u in g.nodes() {
        attr.node_mut(u).balance = 42.0;
    }
    for e in g.edges() {
        attr.edge_mut(e).flow = 1.5;
    }
}

assert!(g.nodes().all(|u| g.node(u).balance == 42.0));
assert!(g.edges().all(|e| g.edge(e).flow == 1.5));

Trait Implementations

impl<'a, G, Gx, Nx, Ex> AttributedGraph<'a> for Attributed<G, Gx, Nx, Ex> where
    G: 'a + IndexGraph<'a>,
    Gx: 'a + Default,
    Nx: 'a + Default,
    Ex: 'a + Default, 

type Graph = G

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

type Attributes = GraphAttrs<'a, G, Gx, Nx, Ex>

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

fn split(&'a mut self) -> (&G, Self::Attributes)

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Return a read-only graph reference and a mutable attributes reference.

fn attr(&self) -> &Gx

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Return the graph attributes.

fn attr_mut(&mut self) -> &mut Gx

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Return the graph attributes.

fn node(&self, u: G::Node) -> &Nx

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Return the attributes of a node.

fn node_mut(&mut self, u: G::Node) -> &mut Nx

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Return the attributes of a node.

fn edge(&self, e: G::Edge) -> &Ex

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Return the attributes of an edge.

fn edge_mut(&mut self, e: G::Edge) -> &mut Ex

👎 Deprecated since 0.17.0:

use rs-graph-derive crate instead

Return the attributes of an edge.

impl<'a, G, Gx, Nx, Ex> Buildable for Attributed<G, Gx, Nx, Ex> where
    G: GraphSize<'a> + Buildable,
    Gx: 'a + Default,
    Nx: 'a + Default,
    Ex: 'a + Default, 

type Builder = AttributedBuilder<G::Builder, Gx, Nx, Ex>

fn new_builder() -> Self::Builder

Create a new builder for this graph type.

fn new_with<F>(f: F) -> Self where
    F: FnOnce(&mut Self::Builder), 

Create a new graph by passing the builder to the callback f.

impl<'a, G, Gx, Nx, Ex> Directed<'a> for Attributed<G, Gx, Nx, Ex> where
    G: Directed<'a>,
    Gx: 'a + Default,
    Nx: 'a + Default,
    Ex: 'a + Default, 

type OutIt = AttributedWrapIt<G::OutIt>

Type of a graph iterator over edges leaving a node.

type InIt = AttributedWrapIt<G::InIt>

Type of a graph iterator over edges entering a node.

type IncidentIt = AttributedWrapIt<G::IncidentIt>

Type of an iterator over all incident edges.

type DirectedEdge = G::DirectedEdge

Type of a directed edge.

fn src(&'a self, e: Self::Edge) -> Self::Node

Return the source node of an edge.

fn snk(&'a self, e: Self::Edge) -> Self::Node

Return the sink node of an edge.

fn out_iter(&'a self, u: Self::Node) -> Self::OutIt

Return a graph iterator over the edges leaving a node.

fn in_iter(&'a self, u: Self::Node) -> Self::InIt

Return a graph iterator over the edges leaving a node.

fn incident_iter(&'a self, u: Self::Node) -> Self::IncidentIt

Return an iterator over all directed edges incident with a node.

fn outedges(&'a self, u: Self::Node) -> GraphIter<'a, Self, Self::OutIt> where
    Self: Sized, 

Return an iterator over the edges leaving a node.

fn outgoing(&'a self) -> OutEdges<'a, Self> where
    Self: Sized, 

Return access to the outgoing arcs via an Adjacencies trait.

fn inedges(&'a self, u: Self::Node) -> GraphIter<'a, Self, Self::InIt> where
    Self: Sized, 

Return an iterator over the edges leaving a node.

fn incoming(&'a self) -> InEdges<'a, Self> where
    Self: Sized, 

Return access to the incoming arcs via an Adjacencies trait.

fn incident_edges(
    &'a self,
    u: Self::Node
) -> GraphIter<'a, Self, Self::IncidentIt> where
    Self: Sized, 

Return an iterator over all directed edges incident with a node.

impl<G, Gx, Nx, Ex, I> GraphIterator<Attributed<G, Gx, Nx, Ex>> for AttributedWrapIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, g: &Attributed<G, Gx, Nx, Ex>) -> Option<I::Item>

fn size_hint(&self, g: &Attributed<G, Gx, Nx, Ex>) -> (usize, Option<usize>)

fn count(self, g: &Attributed<G, Gx, Nx, Ex>) -> usize

fn iter<'a>(self, g: &'a G) -> GraphIter<'a, G, Self> where
    G: Sized, 

impl<'a, G, Gx, Nx, Ex> GraphSize<'a> for Attributed<G, Gx, Nx, Ex> where
    G: GraphSize<'a>,
    Gx: 'a + Default,
    Nx: 'a + Default,
    Ex: 'a + Default, 

type NodeIt = AttributedWrapIt<G::NodeIt>

Type of an iterator over all nodes.

type EdgeIt = AttributedWrapIt<G::EdgeIt>

Type of an iterator over all edges.

fn num_nodes(&self) -> usize

Return the number of nodes in the graph.

fn num_edges(&self) -> usize

Return the number of edges in the graph.

fn nodes_iter(&'a self) -> Self::NodeIt

Return a graph iterator over all nodes.

fn edges_iter(&'a self) -> Self::EdgeIt

Return a graph iterator over all edges.

fn nodes(&'a self) -> NodeIterator<'a, Self> where
    Self: Sized, 

Return an iterator over all nodes.

fn edges(&'a self) -> EdgeIterator<'a, Self> where
    Self: Sized, 

Return an iterator over all edges.

impl<'a, G, Gx, Nx, Ex> GraphType<'a> for Attributed<G, Gx, Nx, Ex> where
    G: GraphType<'a>,
    Gx: Default,
    Nx: Default,
    Ex: Default, 

type Node = G::Node

Type of a node.

type Edge = G::Edge

Type of an edge.

impl<'a, G, Gx, Nx, Ex> IndexGraph<'a> for Attributed<G, Gx, Nx, Ex> where
    G: IndexGraph<'a>,
    Gx: 'a + Default,
    Nx: 'a + Default,
    Ex: 'a + Default, 

fn node_id(&self, u: Self::Node) -> usize

Return a unique id associated with a node.

fn id2node(&'a self, id: usize) -> Self::Node

Return the node associated with the given id.

fn edge_id(&self, e: Self::Edge) -> usize

Return a unique id associated with an edge.

fn id2edge(&'a self, id: usize) -> Self::Edge

Return the edge associated with the given id.

impl<'a, G, Gx, Nx, Ex> Undirected<'a> for Attributed<G, Gx, Nx, Ex> where
    G: Undirected<'a>,
    Gx: 'a + Default,
    Nx: 'a + Default,
    Ex: 'a + Default, 

type NeighIt = AttributedWrapIt<G::NeighIt>

Type of a graph iterator over all incident edges.

fn enodes(&'a self, e: Self::Edge) -> (Self::Node, Self::Node)

Return the nodes connected by an edge.

fn neigh_iter(&'a self, u: Self::Node) -> Self::NeighIt

Return a graph iterator over the edges adjacent to some node.

fn neighs(&'a self, u: Self::Node) -> GraphIter<'a, Self, Self::NeighIt> where
    Self: Sized, 

Return an iterator over the edges adjacent to some node.

fn neighbors(&'a self) -> Neighbors<'a, Self> where
    Self: Sized, 

Return access to the neighbors via an Adjacencies trait.