Trait bevy_internal::utils::petgraph::visit::IntoEdges

pub trait IntoEdges: IntoEdgeReferences + IntoNeighbors {
    type Edges: Iterator<Item = Self::EdgeRef>;

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

Access to the edges of each node.

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

• Directed: All edges from a.
• Undirected: All edges connected to a, with a being the source of each edge.

This is an extended version of the trait IntoNeighbors; the former only iterates over the target node identifiers, while this trait yields edge references (trait EdgeRef).

Required Associated Types

type Edges: Iterator<Item = Self::EdgeRef>

Required Methods

fn edges(self, a: Self::NodeId) -> Self::Edges

Object Safety

This trait is not object safe.

Implementations on Foreign Types

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

where G: IntoEdges,

type Edges = <G as IntoEdges>::Edges

fn edges(self, a: <&'a G as GraphBase>::NodeId) -> <&'a G as IntoEdges>::Edges

Implementors

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

where G: IntoEdges,

type Edges = <G as IntoEdges>::Edges

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

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

type Edges = EdgeFilteredEdges<'a, G, <G as IntoEdges>::Edges, F>

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

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

type Edges = NodeFilteredEdges<'a, G, <G as IntoEdges>::Edges, F>

impl<'a, Ix, E> IntoEdges for &'a List<E, Ix>

where Ix: IndexType,

type Edges = OutgoingEdgeReferences<'a, E, Ix>

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

where N: 'a + NodeTrait, E: 'a, Ty: EdgeType,

type Edges = Edges<'a, N, E, Ty>

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

where Ty: EdgeType, Ix: IndexType,

type Edges = Edges<'a, E, Ty, Ix>

impl<'a, N, E, Ty, Ix> IntoEdges for &'a StableGraph<N, E, Ty, Ix>

where Ty: EdgeType, Ix: IndexType,

type Edges = Edges<'a, E, Ty, Ix>

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

where Ty: EdgeType, Ix: IndexType,

type Edges = Edges<'a, E, Ty, Ix>

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

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

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

impl<G> IntoEdges for Reversed<G>

where G: IntoEdgesDirected,

type Edges = ReversedEdges<<G as IntoEdgesDirected>::EdgesDirected>