Trait Graph 

pub trait Graph {
    type Vertex: Copy + Eq;
    type Label;
    type Vertices<'g>: Iterator<Item = Self::Vertex>
       where Self: 'g;
    type Neighbors<'g>: Iterator<Item = Neighbor<Self::Vertex, Self::Label>>
       where Self: 'g;

    // Required methods
    fn vsize(&self) -> usize;
    fn vertices(&self) -> Self::Vertices<'_>;
    fn neighbors(&self, vertex: Self::Vertex) -> Self::Neighbors<'_>;
}

A finite graph whose outgoing arcs can be iterated without allocation.

Required Associated Types

type Vertex: Copy + Eq

type Label

type Vertices<'g>: Iterator<Item = Self::Vertex> where Self: 'g

type Neighbors<'g>: Iterator<Item = Neighbor<Self::Vertex, Self::Label>> where Self: 'g

Required Methods

fn vsize(&self) -> usize

fn vertices(&self) -> Self::Vertices<'_>

fn neighbors(&self, vertex: Self::Vertex) -> Self::Neighbors<'_>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Graph for AdjacencyListGraph

type Vertex = usize

type Label = usize

type Vertices<'g> = Range<usize>

type Neighbors<'g> = Copied<Iter<'g, Neighbor<usize, usize>>>

impl<A> Graph for GridGraph<A>

where GridDirectionIter<A>: Iterator<Item = GridDirection>,

type Vertex = (usize, usize)

type Label = GridDirection

type Vertices<'g> = GridVertices where A: 'g

type Neighbors<'g> = Map<GridAdjacency<'g, A>, fn(((usize, usize), GridDirection)) -> Neighbor<(usize, usize), GridDirection>> where A: 'g

impl<D> Graph for SparseGraph<D>

where D: SparseGraphConstruction,

type Vertex = usize

type Label = usize

type Vertices<'g> = Range<usize> where D: 'g

type Neighbors<'g> = Copied<Iter<'g, Neighbor<usize, usize>>> where D: 'g

impl<Fa, I, T> Graph for UsizeGraph<Fa>

where I: Iterator<Item = (usize, T)>, Fa: Fn(usize) -> I,

type Vertex = usize

type Label = T

type Vertices<'g> = Range<usize> where Fa: 'g

type Neighbors<'g> = Map<I, fn((usize, T)) -> Neighbor<usize, T>> where Fa: 'g

impl<V, Fv, Fa, Iv, Ia, T> Graph for ClosureGraph<V, Fv, Fa>

where V: Eq + Copy, Iv: Iterator<Item = V>, Fv: Fn() -> Iv, Ia: Iterator<Item = (V, T)>, Fa: Fn(V) -> Ia,

type Vertex = V

type Label = T

type Vertices<'g> = Iv where V: 'g, Fv: 'g, Fa: 'g

type Neighbors<'g> = Map<Ia, fn((V, T)) -> Neighbor<V, T>> where V: 'g, Fv: 'g, Fa: 'g