Struct rs_graph::linkedlistgraph::LinkedListGraph

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

The linked list based graph data structure.

Methods

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

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

Trait Implementations

impl<'a, ID, N, E, B> GraphType<'a> for LinkedListGraph<ID, N, E, B> 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, E, B> GraphSize<'a> for LinkedListGraph<ID, N, E, B> 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: 'a, E: 'a, B: 'a> Undirected<'a> for LinkedListGraph<ID, N, E, B> where
    ID: 'a + PrimInt + Unsigned, 

type NeighIter = NeighIter<'a, ID, E, B>

Type of an iterator over all incident edges.

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

Return the nodes connected by an edge.

fn neighs(&'a self, u: Self::Node) -> Self::NeighIter

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.

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

type OutEdgeIter = OutEdgeIter<'a, ID, E, B>

Type of an iterator over the forward edges leaving a node.

type InEdgeIter = InEdgeIter<'a, ID, E, B>

Type of an iterator over the backward edges entering a node.

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 outedges(&'a self, u: Self::Node) -> Self::OutEdgeIter

Return an iterator over the outgoing edges of a node.

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

Return an iterator over the incoming edges of a node.

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

Return access to the outgoing arcs via an Adjacencies trait.

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

Return access to the incoming arcs via an Adjacencies trait.

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

fn is_reverse(&self, e: Self::Edge, f: Self::Edge) -> bool

Return true if e is the reverse edge of f.

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

Return the reverse edge of e.

fn is_forward(&self, e: Self::Edge) -> bool

Return true if e is a forward edge.

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

Return the forward edge of e.

fn is_backward(&self, e: Self::Edge) -> bool

Return true if e is a backward edge.

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

Return the backward edge of e.

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

Return the source of the directed edge e.

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

Return the sink of the directed edge e.

impl<'a, ID, N: 'a, E: 'a, B: 'a> IndexGraph<'a> for LinkedListGraph<ID, N, E, B> 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, B: 'a> IndexNetwork<'a> for LinkedListGraph<ID, N, E, B> where
    ID: 'a + PrimInt + Unsigned, 

fn id2biedge(&self, id: usize) -> Self::Edge

Return the edge associated with the given id.

fn biedge_id(&self, a: Self::Edge) -> usize

Return a unique id associated with a directed edge.

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

type Graph = Self

The graph type produced by this builder.

type Node = Node<ID>

The type of a nodes.

type Edge = Edge<ID>

The type of an edge.

fn with_capacities(nnodes: usize, nedges: usize) -> Self

Create a new, empty builder.

fn reserve(&mut self, nnodes: usize, nedges: usize)

Reserve memory for a certain number of nodes and edges.

fn add_node(&mut self) -> Self::Node

Add a new node.

fn add_edge(&mut self, u: Self::Node, v: Self::Node) -> Self::Edge

Add a new edge.

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

Return a unique id of a node.

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

Return a unique id of an edge.

fn to_graph(self) -> Self

Turn the builder into a graph.

fn new() -> Self

Create a new, empty builder.

fn add_nodes(&mut self, n: usize) -> Vec<Self::Node>

Add n new nodes.

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

type Builder = Self

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

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

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

impl<'a, ID, N: 'a, E: 'a, B: 'a> EdgeAttributes<'a, LinkedListGraph<ID, N, E, B>, E> for LinkedListGraph<ID, N, E, B> 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: 'a, E: 'a, B: 'a> BiEdgeAttributes<'a, LinkedListGraph<ID, N, E, B>, B> for LinkedListGraph<ID, N, E, B> where
    ID: 'a + PrimInt + Unsigned, 

fn biedge(&self, e: Self::Edge) -> &B

fn biedge_mut(&mut self, e: Self::Edge) -> &mut B

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

fn default() -> Self

Returns the "default value" for a type.

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

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

Serialize this value into the given Serde serializer.

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

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

Deserialize this value from the given Serde deserializer.