Trait IntoEdgesDirected

pub trait IntoEdgesDirected: IntoEdges + IntoNeighborsDirected {
    type EdgesDirected: Iterator<Item = Self::EdgeRef>;

    // Required method
    fn edges_directed(
        self,
        a: Self::NodeId,
        dir: Direction,
    ) -> Self::EdgesDirected;
}

Access to all edges of each node, in the specified direction.

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

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

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

Required Associated Types

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

Required Methods

fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::EdgesDirected

Object Safety

This trait is not object safe.

Implementations on Foreign Types

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

where G: IntoEdgesDirected,

type EdgesDirected = <G as IntoEdgesDirected>::EdgesDirected

fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::EdgesDirected

Implementors

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

where G: IntoEdgesDirected,

type EdgesDirected = <G as IntoEdgesDirected>::EdgesDirected

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

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

type EdgesDirected = EdgeFilteredEdges<'a, G, <G as IntoEdgesDirected>::EdgesDirected, F>

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

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

type EdgesDirected = NodeFilteredEdges<'a, G, <G as IntoEdgesDirected>::EdgesDirected, F>

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

type EdgesDirected = Edges<'a, Directed, Null, Ix>

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

where Ty: EdgeType, Ix: IndexType,

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

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

where Ty: EdgeType, Ix: IndexType,

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

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

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

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

impl<G> IntoEdgesDirected for Reversed<G>

where G: IntoEdgesDirected,

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