Trait bevy::utils::petgraph::visit::IntoNeighborsDirected

pub trait IntoNeighborsDirected: IntoNeighbors {
    type NeighborsDirected: Iterator<Item = Self::NodeId>;

    // Required method
    fn neighbors_directed(
        self,
        n: Self::NodeId,
        d: Direction
    ) -> Self::NeighborsDirected;
}

Access to the neighbors of each node, through incoming or outgoing edges.

Depending on the graph’s edge type, the neighbors of a given directionality are:

• Directed, Outgoing: All targets of edges from a.
• Directed, Incoming: All sources of edges to a.
• Undirected: All other endpoints of edges connected to a.

Required Associated Types

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

Required Methods

fn neighbors_directed( self, n: Self::NodeId, d: Direction ) -> Self::NeighborsDirected

Implementations on Foreign Types

impl<'a, G> IntoNeighborsDirected for &'a Gwhere G: IntoNeighborsDirected,

type NeighborsDirected = <G as IntoNeighborsDirected>::NeighborsDirected

fn neighbors_directed( self, n: <&'a G as GraphBase>::NodeId, d: Direction ) -> <&'a G as IntoNeighborsDirected>::NeighborsDirected

Implementors

impl<'a, 'b, G> IntoNeighborsDirected for &'b Frozen<'a, G>where G: IntoNeighborsDirected,

type NeighborsDirected = <G as IntoNeighborsDirected>::NeighborsDirected

impl<'a, G, F> IntoNeighborsDirected for &'a EdgeFiltered<G, F>where G: IntoEdgesDirected, F: FilterEdge<<G as IntoEdgeReferences>::EdgeRef>,

type NeighborsDirected = EdgeFilteredNeighborsDirected<'a, G, F>

impl<'a, G, F> IntoNeighborsDirected for &'a NodeFiltered<G, F>where G: IntoNeighborsDirected, F: FilterNode<<G as GraphBase>::NodeId>,

type NeighborsDirected = NodeFilteredNeighbors<'a, <G as IntoNeighborsDirected>::NeighborsDirected, F>

impl<'a, N, E, Null, Ix> IntoNeighborsDirected for &'a MatrixGraph<N, E, Directed, Null, Ix>where E: 'a, Null: Nullable<Wrapped = E>, Ix: IndexType,

type NeighborsDirected = Neighbors<'a, Directed, Null, Ix>

impl<'a, N, E, Ty> IntoNeighborsDirected for &'a GraphMap<N, E, Ty>where N: 'a + Copy + Ord + Hash, Ty: EdgeType,

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

impl<'a, N, E, Ty, Ix> IntoNeighborsDirected for &'a StableGraph<N, E, Ty, Ix>where E: 'a, Ty: EdgeType, Ix: IndexType,

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

impl<'a, N, E, Ty, Ix> IntoNeighborsDirected for &'a Graph<N, E, Ty, Ix>where E: 'a, Ty: EdgeType, Ix: IndexType,

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

impl<G> IntoNeighborsDirected for Reversed<G>where G: IntoNeighborsDirected,

type NeighborsDirected = <G as IntoNeighborsDirected>::NeighborsDirected