Trait rs_graph::traits::GraphSize[−][src]

pub trait GraphSize<'a>: GraphType<'a> {
    type NodeIt: GraphIterator<Self, Item = Self::Node>;
    type EdgeIt: GraphIterator<Self, Item = Self::Edge>;
    fn num_nodes(&self) -> usize;

    fn num_edges(&self) -> usize;

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

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

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

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

A (finite) graph with a known number of nodes and edges.

Finite graphs also provide access to the list of all nodes and edges.

Associated Types

type NodeIt: GraphIterator<Self, Item = Self::Node>[src]

Type of an iterator over all nodes.

type EdgeIt: GraphIterator<Self, Item = Self::Edge>[src]

Type of an iterator over all edges.

Loading content...

Required methods

fn num_nodes(&self) -> usize[src]

Return the number of nodes in the graph.

fn num_edges(&self) -> usize[src]

Return the number of edges in the graph.

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

Return a graph iterator over all nodes.

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

Return a graph iterator over all edges.

This iterator traverses only the forward edges.

Loading content...

Provided methods

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

Return an iterator over all nodes.

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

Return an iterator over all edges.

This iterator traverses only the forward edges.

Loading content...

Implementations on Foreign Types

impl<'a, 'g: 'a, G> GraphSize<'a> for &'g G where
    G: GraphSize<'g>, [src]

type NodeIt = WrapIt<G::NodeIt>

type EdgeIt = WrapIt<G::EdgeIt>

Loading content...

Implementors

impl<'a, 'g: 'a, G> GraphSize<'a> for Network<'g, G> where
    G: Digraph<'g>, [src]

type NodeIt = NetworkNodeIt<G::NodeIt>

type EdgeIt = NetworkEdgeIt<G, G::EdgeIt>

impl<'a, 'g: 'a, G> GraphSize<'a> for ReverseDigraph<'g, G> where
    G: GraphSize<'g>, [src]

type NodeIt = ReverseWrapIt<G::NodeIt>

type EdgeIt = ReverseWrapIt<G::EdgeIt>

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, [src]

type NodeIt = AttributedWrapIt<G::NodeIt>

type EdgeIt = AttributedWrapIt<G::EdgeIt>

impl<'a, G, P> GraphSize<'a> for FilteredGraph<'a, G, P> where
    G: GraphSize<'a>,
    P: 'a + for<'r> Fn(&'r G::Edge) -> bool, [src]

type NodeIt = FilterWrapIt<G::NodeIt>

type EdgeIt = FilterEdgeIt<G::EdgeIt>

impl<'a, ID> GraphSize<'a> for VecGraph<ID> where
    ID: 'a + PrimInt + Unsigned, [src]

type NodeIt = NodeIt<ID>

type EdgeIt = EdgeIt<ID>

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

type NodeIt = NodeIt<ID>

type EdgeIt = EdgeIt<ID>

Loading content...