Trait rs_graph::traits::GraphIterator

pub trait GraphIterator<G: ?Sized>: Clone {
    type Item;
    fn next(&mut self, g: &G) -> Option<Self::Item>;

    fn size_hint(&self, _g: &G) -> (usize, Option<usize>) { ... }
    fn count(self, g: &G) -> usize { ... }
    fn iter<'a>(self, g: &'a G) -> GraphIter<'a, G, Self>
    where
        G: Sized,
    { ... }
}

A graph iterator.

This is roughly the same interface as a standard iterator. However, all its method take additionally the graph itself as parameter. This allows the iterator to not contain a reference to internal graph data.

This might be useful for algorithms that need to store several iterators because they require less memory (they do not need to store a reference to the same graph, each!).

Associated Types

type Item

Loading content...

Required methods

fn next(&mut self, g: &G) -> Option<Self::Item>

Loading content...

Provided methods

fn size_hint(&self, _g: &G) -> (usize, Option<usize>)

fn count(self, g: &G) -> usize

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

Loading content...

Implementors

impl<'a, A, I> GraphIterator<&'a A> for AdjacenciesWrapIt<I> where
    I: GraphIterator<A>, 

type Item = I::Item

fn next(&mut self, adj: &&'a A) -> Option<Self::Item>

fn size_hint(&self, adj: &&'a A) -> (usize, Option<usize>)

fn count(self, adj: &&'a A) -> usize

impl<'a, G, I> GraphIterator<&'a G> for WrapIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, g: &&'a G) -> Option<Self::Item>

fn size_hint(&self, g: &&'a G) -> (usize, Option<usize>)

fn count(self, g: &&'a G) -> usize

impl<'a, G, I> GraphIterator<Network<'a, G>> for NetworkEdgeIt<G, I> where
    I: GraphIterator<G>,
    I::Item: Clone, 

type Item = NetworkEdge<I::Item>

fn next(&mut self, net: &Network<'a, G>) -> Option<Self::Item>

fn size_hint(&self, net: &Network<'a, G>) -> (usize, Option<usize>)

fn count(self, net: &Network<'a, G>) -> usize

impl<'a, G, I> GraphIterator<Network<'a, G>> for NetworkNodeIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, net: &Network<'a, G>) -> Option<Self::Item>

fn size_hint(&self, net: &Network<'a, G>) -> (usize, Option<usize>)

fn count(self, net: &Network<'a, G>) -> usize

impl<'a, G, I, N, D> GraphIterator<Network<'a, G>> for NetworkInIt<I> where
    I: GraphIterator<G, Item = (D, N)>,
    D: DirectedEdge, 

type Item = (NetworkEdge<D::Edge>, N)

fn next(&mut self, net: &Network<'a, G>) -> Option<Self::Item>

fn size_hint(&self, net: &Network<'a, G>) -> (usize, Option<usize>)

fn count(self, net: &Network<'a, G>) -> usize

impl<'a, G, I, N, D> GraphIterator<Network<'a, G>> for NetworkIncidentIt<I, I::Item> where
    I: GraphIterator<G, Item = (D, N)>,
    N: Clone,
    D: DirectedEdge + Clone, 

type Item = (NetworkDirectedEdge<NetworkEdge<D::Edge>>, N)

fn next(&mut self, net: &Network<'a, G>) -> Option<Self::Item>

fn size_hint(&self, net: &Network<'a, G>) -> (usize, Option<usize>)

fn count(self, net: &Network<'a, G>) -> usize

impl<'a, G, I, N, D> GraphIterator<Network<'a, G>> for NetworkOutIt<I> where
    I: GraphIterator<G, Item = (D, N)>,
    D: DirectedEdge, 

type Item = (NetworkEdge<D::Edge>, N)

fn next(&mut self, net: &Network<'a, G>) -> Option<Self::Item>

fn size_hint(&self, net: &Network<'a, G>) -> (usize, Option<usize>)

fn count(self, net: &Network<'a, G>) -> usize

impl<'a, G, I, N, E> GraphIterator<Network<'a, G>> for NetworkNeighIt<G, I> where
    N: Clone,
    E: Clone,
    I: GraphIterator<G, Item = (E, N)>, 

type Item = (NetworkEdge<E>, N)

fn next(&mut self, net: &Network<'a, G>) -> Option<Self::Item>

fn size_hint(&self, net: &Network<'a, G>) -> (usize, Option<usize>)

fn count(self, net: &Network<'a, G>) -> usize

impl<'a, G, P> GraphIterator<FilteredGraph<'a, G, P>> for FilterEdgeIt<G::EdgeIt> where
    G: GraphSize<'a>,
    P: for<'r> Fn(&'r G::Edge) -> bool, 

type Item = G::Edge

fn next(&mut self, g: &FilteredGraph<'a, G, P>) -> Option<G::Edge>

impl<'a, G, P, I> GraphIterator<FilteredGraph<'a, G, P>> for FilterWrapIt<I> where
    G: GraphType<'a>,
    P: for<'r> Fn(&'r G::Edge) -> bool,
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, g: &FilteredGraph<'a, G, P>) -> Option<I::Item>

fn size_hint(&self, g: &FilteredGraph<'a, G, P>) -> (usize, Option<usize>)

fn count(self, g: &FilteredGraph<'a, G, P>) -> usize

impl<'a, G, P, I> GraphIterator<FilteredGraph<'a, G, P>> for rs_graph::filtered::Filtered<I> where
    G: GraphType<'a>,
    P: for<'r> Fn(&'r G::Edge) -> bool,
    I: GraphIterator<G, Item = (G::Edge, G::Node)>, 

type Item = I::Item

fn next(&mut self, g: &FilteredGraph<'a, G, P>) -> Option<Self::Item>

impl<'a, G, P, I> GraphIterator<FilteredGraph<'a, G, P>> for FilteredIncidentIt<I> where
    G: Directed<'a>,
    P: for<'r> Fn(&'r G::Edge) -> bool,
    I: GraphIterator<G, Item = (G::DirectedEdge, G::Node)>, 

type Item = I::Item

fn next(&mut self, g: &FilteredGraph<'a, G, P>) -> Option<Self::Item>

impl<'a, ID> GraphIterator<VecGraph<ID>> for rs_graph::vecgraph::EdgeIt<ID> where
    ID: 'a + PrimInt + Unsigned, 

type Item = Edge<ID>

fn next(&mut self, _g: &VecGraph<ID>) -> Option<Self::Item>

fn size_hint(&self, _g: &VecGraph<ID>) -> (usize, Option<usize>)

fn count(self, _g: &VecGraph<ID>) -> usize

impl<'a, ID> GraphIterator<VecGraph<ID>> for rs_graph::vecgraph::NeighIt<'a, ID> where
    ID: 'a + PrimInt + Unsigned, 

type Item = (Edge<ID>, Node<ID>)

fn next(&mut self, g: &VecGraph<ID>) -> Option<Self::Item>

impl<'a, ID> GraphIterator<VecGraph<ID>> for rs_graph::vecgraph::NodeIt<ID> where
    ID: 'a + PrimInt + Unsigned, 

type Item = Node<ID>

fn next(&mut self, _g: &VecGraph<ID>) -> Option<Self::Item>

fn size_hint(&self, _g: &VecGraph<ID>) -> (usize, Option<usize>)

fn count(self, _g: &VecGraph<ID>) -> usize

impl<'a, ID, N, E> GraphIterator<LinkedListGraph<ID, N, E>> for rs_graph::linkedlistgraph::NeighIt<ID> where
    ID: 'a + PrimInt + Unsigned, 

type Item = (Edge<ID>, Node<ID>)

fn next(&mut self, g: &LinkedListGraph<ID, N, E>) -> Option<Self::Item>

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

type Item = (Edge<ID>, Node<ID>)

fn next(&mut self, g: &LinkedListGraph<ID, N, E>) -> Option<Self::Item>

impl<'a, ID, N: 'a, E: 'a> GraphIterator<LinkedListGraph<ID, N, E>> for rs_graph::linkedlistgraph::EdgeIt<ID> where
    ID: 'a + PrimInt + Unsigned, 

type Item = Edge<ID>

fn next(&mut self, _g: &LinkedListGraph<ID, N, E>) -> Option<Self::Item>

fn size_hint(&self, _g: &LinkedListGraph<ID, N, E>) -> (usize, Option<usize>)

fn count(self, _g: &LinkedListGraph<ID, N, E>) -> usize

impl<'a, ID, N: 'a, E: 'a> GraphIterator<LinkedListGraph<ID, N, E>> for rs_graph::linkedlistgraph::NodeIt<ID> where
    ID: 'a + PrimInt + Unsigned, 

type Item = Node<ID>

fn next(&mut self, _g: &LinkedListGraph<ID, N, E>) -> Option<Self::Item>

fn size_hint(&self, _g: &LinkedListGraph<ID, N, E>) -> (usize, Option<usize>)

fn count(self, _g: &LinkedListGraph<ID, N, E>) -> usize

impl<'g, G, I> GraphIterator<InEdges<'g, G>> for AdjacenciesWrapIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, adj: &InEdges<'g, G>) -> Option<Self::Item>

fn size_hint(&self, adj: &InEdges<'g, G>) -> (usize, Option<usize>)

fn count(self, adj: &InEdges<'g, G>) -> usize

impl<'g, G, I> GraphIterator<Neighbors<'g, G>> for AdjacenciesWrapIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, adj: &Neighbors<'g, G>) -> Option<Self::Item>

fn size_hint(&self, adj: &Neighbors<'g, G>) -> (usize, Option<usize>)

fn count(self, adj: &Neighbors<'g, G>) -> usize

impl<'g, G, I> GraphIterator<OutEdges<'g, G>> for AdjacenciesWrapIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, adj: &OutEdges<'g, G>) -> Option<Self::Item>

fn size_hint(&self, adj: &OutEdges<'g, G>) -> (usize, Option<usize>)

fn count(self, adj: &OutEdges<'g, G>) -> usize

impl<'g, G, I> GraphIterator<EdgeIndexer<'g, G>> for IndexerIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, indexer: &EdgeIndexer<'g, G>) -> Option<Self::Item>

fn size_hint(&self, indexer: &EdgeIndexer<'g, G>) -> (usize, Option<usize>)

fn count(self, indexer: &EdgeIndexer<'g, G>) -> usize

impl<'g, G, I> GraphIterator<NodeIndexer<'g, G>> for IndexerIt<I> where
    I: GraphIterator<G>, 

type Item = I::Item

fn next(&mut self, indexer: &NodeIndexer<'g, G>) -> Option<Self::Item>

fn size_hint(&self, indexer: &NodeIndexer<'g, G>) -> (usize, Option<usize>)

fn count(self, indexer: &NodeIndexer<'g, G>) -> usize

impl<A, P, I> GraphIterator<FilterAdjacencies<A, P>> for rs_graph::adjacencies::Filtered<I> where
    I: GraphIterator<A>,
    P: for<'r> Fn(&'r I::Item) -> bool, 

type Item = I::Item

fn next(&mut self, adj: &FilterAdjacencies<A, P>) -> Option<Self::Item>

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

Loading content...