Trait 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

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> IntoEdges for &'a G

where G: IntoEdges,

type Edges = <G as IntoEdges>::Edges

fn edges(self, a: Self::NodeId) -> Self::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::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::NodeId>,

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

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

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

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 Graph<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: EdgeType, Null: Nullable<Wrapped = E>, Ix: IndexType> IntoEdges for &'a MatrixGraph<N, E, Ty, Null, Ix>

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

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

where N: NodeTrait + 'a, Ty: EdgeType, S: BuildHasher,

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

impl<G> IntoEdges for Reversed<G>

where G: IntoEdgesDirected,

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