Struct rs_graph::linkedlistgraph::LinkedListGraph

pub struct LinkedListGraph<ID = u32, N = (), E = ()> { /* fields omitted */ }

The linked list based graph data structure.

Methods

impl<ID, N, E> LinkedListGraph<ID, N, E> where
    ID: PrimInt + Unsigned, 

pub fn new() -> LinkedListGraph<ID, N, E>

Trait Implementations

impl<ID, N, E> Buildable for LinkedListGraph<ID, N, E> where
    ID: PrimInt + Unsigned,
    N: Default,
    E: Default, 

type Builder = LinkedListGraphBuilder<ID, N, E>

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<ID, N, E> Default for LinkedListGraph<ID, N, E> where
    ID: PrimInt + Unsigned, 

fn default() -> Self

Returns the "default value" for a type.

impl<'de, ID, N, E> Deserialize<'de> for LinkedListGraph<ID, N, E> where
    ID: Deserialize<'de>,
    N: Deserialize<'de>,
    E: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a, ID, N: 'a, E: 'a> Directed<'a> for LinkedListGraph<ID, N, E> where
    ID: 'a + PrimInt + Unsigned, 

type OutEdge = OutEdge<ID>

Type of a graph iterator over edges leaving a node.

type InEdge = InEdge<ID>

Type of a graph iterator over edges entering a node.

type IncidentEdge = IncidentEdge<ID>

Type of an iterator over all incident edges.

type DirectedEdge = Self::Edge

Type of a directed edge.

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

Return the source node of an edge.

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

Return the sink node of an edge.

fn first_out(&'a self, u: Self::Node) -> Option<Self::OutEdge>

Return an iterator over the edges leaving a node.

fn next_out(&'a self, it: Self::OutEdge) -> Option<Self::OutEdge>

Advance the iterator to the next outgoing edge.

fn get_out(&'a self, it: &Self::OutEdge) -> (Self::Edge, Self::Node)

Return the edge and sink node of an outgoing edge iterator.

fn first_in(&'a self, u: Self::Node) -> Option<Self::InEdge>

Return an iterator over the edges entering a node.

fn next_in(&'a self, it: Self::InEdge) -> Option<Self::InEdge>

Advance the iterator to the next incoming edge.

fn get_in(&'a self, it: &Self::InEdge) -> (Self::Edge, Self::Node)

Return the edge and sink node of an incoming edge iterator.

fn first_incident(&'a self, u: Self::Node) -> Option<Self::IncidentEdge>

Return an iterator over the edges entering a node.

fn next_incident(&'a self, it: Self::IncidentEdge) -> Option<Self::IncidentEdge>

Advance the iterator to the next incoming edge.

fn get_incident(
    &'a self,
    it: &Self::IncidentEdge
) -> (Self::DirectedEdge, Self::Node)

Return the edge and sink node of an incoming edge iterator.

Important traits for OutEdgeIter<'a, G>

impl<'a, G> Iterator for OutEdgeIter<'a, G> where
    G: Directed<'a>,  type Item = (G::Edge, G::Node);

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

Return an iterator over the outgoing edges of a node.

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

Return access to the outgoing arcs via an Adjacencies trait.

Important traits for InEdgeIter<'a, G>

impl<'a, G> Iterator for InEdgeIter<'a, G> where
    G: Directed<'a>,  type Item = (G::Edge, G::Node);

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

Return an iterator over the incoming edges of a node.

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

Return access to the incoming arcs via an Adjacencies trait.

Important traits for IncidentEdgeIter<'a, G>

impl<'a, G> Iterator for IncidentEdgeIter<'a, G> where
    G: Directed<'a>,  type Item = (G::DirectedEdge, G::Node);

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

Return access to all incident edges of a node.

impl<'a, ID, N: 'a, E: 'a> EdgeAttributes<'a, LinkedListGraph<ID, N, E>, E> for LinkedListGraph<ID, N, E> where
    ID: 'a + PrimInt + Unsigned, 

fn edge(&self, e: Self::Edge) -> &E

fn edge_mut(&mut self, e: Self::Edge) -> &mut E

impl<'a, ID, N, E> GraphSize<'a> for LinkedListGraph<ID, N, E> where
    ID: 'a + PrimInt + Unsigned, 

type NodeIter = NodeIter<ID>

Type of an iterator over all nodes.

type EdgeIter = EdgeIter<ID>

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(&'a self) -> Self::NodeIter

Return an iterator over all nodes.

fn edges(&self) -> Self::EdgeIter

Return an iterator over all edges.

impl<'a, ID, N, E> GraphType<'a> for LinkedListGraph<ID, N, E> where
    ID: 'a + PrimInt + Unsigned, 

type Node = Node<ID>

Type of a node.

type Edge = Edge<ID>

Type of an edge.

impl<'a, ID, N: 'a, E: 'a> IndexGraph<'a> for LinkedListGraph<ID, N, E> where
    ID: 'a + PrimInt + Unsigned, 

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

Return a unique id associated with a node.

fn id2node(&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(&self, id: usize) -> Self::Edge

Return the edge associated with the given id.

impl<'a, ID, N: 'a, E: 'a> NodeAttributes<'a, LinkedListGraph<ID, N, E>, N> for LinkedListGraph<ID, N, E> where
    ID: 'a + PrimInt + Unsigned, 

fn node(&self, u: Self::Node) -> &N

fn node_mut(&mut self, u: Self::Node) -> &mut N

impl<ID, N, E> Serialize for LinkedListGraph<ID, N, E> where
    ID: Serialize,
    N: Serialize,
    E: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<'a, ID, N: 'a, E: 'a> Undirected<'a> for LinkedListGraph<ID, N, E> where
    ID: 'a + PrimInt + Unsigned, 

type Neigh = Neigh<ID>

Type of a graph iterator over all incident edges.

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

Return the nodes connected by an edge.

fn first_neigh(&'a self, u: Self::Node) -> Option<Self::Neigh>

Return an iterator over the edges adjacent to some node.

fn next_neigh(&'a self, it: Self::Neigh) -> Option<Self::Neigh>

Advance the iterator to the next adjacent edge.

fn get_neigh(&'a self, it: &Self::Neigh) -> (Self::Edge, Self::Node)

Return the edge and neighboring node of an iterator.

Important traits for NeighIter<'a, G>

impl<'a, G> Iterator for NeighIter<'a, G> where
    G: Undirected<'a>,  type Item = (G::Edge, G::Node);

fn neighs(&'a self, u: Self::Node) -> NeighIter<Self> 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.