Trait IntoNeighbors

pub trait IntoNeighbors: GraphRef {
    type Neighbors: Iterator<Item = Self::NodeId>;

    // Required method
    fn neighbors(self, a: Self::NodeId) -> Self::Neighbors;
}

Access to the neighbors of each node

The neighbors are, depending on the graph’s edge type:

• Directed: All targets of edges from a.
• Undirected: All other endpoints of edges connected to a.

Required Associated Types

type Neighbors: Iterator<Item = Self::NodeId>

Required Methods

fn neighbors(self, a: Self::NodeId) -> Self::Neighbors

Return an iterator of the neighbors of node a.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, G> IntoNeighbors for &'a G

where G: IntoNeighbors,

type Neighbors = <G as IntoNeighbors>::Neighbors

fn neighbors(self, a: Self::NodeId) -> Self::Neighbors

Implementors

impl<'a, 'b, G> IntoNeighbors for &'b Frozen<'a, G>

where G: IntoNeighbors,

type Neighbors = <G as IntoNeighbors>::Neighbors

impl<'a, E, Ix: IndexType> IntoNeighbors for &'a List<E, Ix>

type Neighbors = Neighbors<'a, E, Ix>

impl<'a, G, F> IntoNeighbors for &'a EdgeFiltered<G, F>

where G: IntoEdges, F: FilterEdge<G::EdgeRef>,

type Neighbors = EdgeFilteredNeighbors<'a, G, F>

impl<'a, G, F> IntoNeighbors for &'a NodeFiltered<G, F>

where G: IntoNeighbors, F: FilterNode<G::NodeId>,

type Neighbors = NodeFilteredNeighbors<'a, <G as IntoNeighbors>::Neighbors, F>

impl<'a, N, E, Ty, Ix> IntoNeighbors for &'a Csr<N, E, Ty, Ix>

where Ty: EdgeType, Ix: IndexType,

type Neighbors = Neighbors<'a, Ix>

impl<'a, N, E, Ty, S> IntoNeighbors for &'a GraphMap<N, E, Ty, S>

where N: Copy + Ord + Hash + 'a, Ty: EdgeType, S: BuildHasher,

type Neighbors = Neighbors<'a, N, Ty>

impl<'a, N, E: 'a, Ty, Ix> IntoNeighbors for &'a Graph<N, E, Ty, Ix>

where Ty: EdgeType, Ix: IndexType,

type Neighbors = Neighbors<'a, E, Ix>

impl<G> IntoNeighbors for Reversed<G>

where G: IntoNeighborsDirected,

type Neighbors = <G as IntoNeighborsDirected>::NeighborsDirected