Trait bevy::utils::petgraph::visit::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.

Object Safety

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: <&'a G as GraphBase>::NodeId ) -> <&'a G as IntoNeighbors>::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> IntoNeighbors for &'a List<E, Ix>

where Ix: IndexType,

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

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

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

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

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

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

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

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

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

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

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, Ix> IntoNeighbors for &'a StableGraph<N, E, Ty, Ix>

where E: 'a, Ty: EdgeType, Ix: IndexType,

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

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

where E: 'a, Ty: EdgeType, Ix: IndexType,

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

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

where E: 'a, Ty: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType,

type Neighbors = Neighbors<'a, Ty, Null, Ix>

impl<G> IntoNeighbors for Reversed<G>

where G: IntoNeighborsDirected,

type Neighbors = <G as IntoNeighborsDirected>::NeighborsDirected