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

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> 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, 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: '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>