## LinkedGraph

# Struct LinkedGraph

Source

    pub struct LinkedGraph<N, E> {
        nodes: Vec<Node<N>>,
        edges: Vec<Edge<E>>,
    }

Expand description

A concrete graph implementation that supports:

- Nodes and/or edges labelled with custom data types (`N` and `E` respectively).
- Incremental addition of new nodes/edges (but not removal).
- Flat storage of node/edge data in a pair of vectors.
- Iteration over any node’s out-edges or in-edges, via linked lists threaded through the node/edge data.

## §Caution

This is an older graph implementation that is still used by some pieces of diagnostic/debugging code. New code that needs a graph data structure should consider using `VecGraph` instead, or implementing its own special-purpose graph with the specific features needed.

This graph implementation predates the later graph traits, and does not implement those traits, so it has its own implementations of a few basic graph algorithms.

## Fields§

§`nodes: Vec<Node<N>>`§`edges: Vec<Edge<E>>`

## Implementations§

Source§

### impl<N: Debug, E: Debug> LinkedGraph<N, E>

Source

#### pub fn new() -> Self

Source

#### pub fn with_capacity(nodes: usize, edges: usize) -> Self

Source

#### pub fn all_nodes(&self) -> &[Node<N>]

Source

#### pub fn len_nodes(&self) -> usize

Source

#### pub fn all_edges(&self) -> &[Edge<E>]

Source

#### pub fn len_edges(&self) -> usize

Source

#### pub fn next_node_index(&self) -> NodeIndex

Source

#### pub fn add_node(&mut self, data: N) -> NodeIndex

Source

#### pub fn mut_node_data(&mut self, idx: NodeIndex) -> &mut N

Source

#### pub fn node_data(&self, idx: NodeIndex) -> &N

Source

#### pub fn node(&self, idx: NodeIndex) -> &Node<N>

Source

#### pub fn next_edge_index(&self) -> EdgeIndex

Source

#### pub fn add_edge( &mut self, source: NodeIndex, target: NodeIndex, data: E, ) -> EdgeIndex

Source

#### pub fn edge(&self, idx: EdgeIndex) -> &Edge<E>

Source

#### pub fn enumerated_nodes(&self) -> impl Iterator<Item = (NodeIndex, &Node<N>)>

Source

#### pub fn enumerated_edges(&self) -> impl Iterator<Item = (EdgeIndex, &Edge<E>)>

Source

#### pub fn each_node<'a>( &'a self, f: impl FnMut(NodeIndex, &'a Node<N>) -> bool, ) -> bool

Iterates over all edges defined in the graph.

Source

#### pub fn each_edge<'a>( &'a self, f: impl FnMut(EdgeIndex, &'a Edge<E>) -> bool, ) -> bool

Iterates over all edges defined in the graph

Source

#### pub fn outgoing_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E> ⓘ

Source

#### pub fn incoming_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E> ⓘ

Source

#### pub fn adjacent_edges( &self, source: NodeIndex, direction: Direction, ) -> AdjacentEdges<'_, N, E> ⓘ

Source

#### pub fn successor_nodes( &self, source: NodeIndex, ) -> impl Iterator<Item = NodeIndex>

Source

#### pub fn predecessor_nodes( &self, target: NodeIndex, ) -> impl Iterator<Item = NodeIndex>

Source

#### pub fn depth_traverse( &self, start: NodeIndex, direction: Direction, ) -> DepthFirstTraversal<'_, N, E> ⓘ

Source

#### pub fn nodes_in_postorder( &self, direction: Direction, entry_node: NodeIndex, ) -> Vec<NodeIndex>

## Auto Trait Implementations§

§

### impl<N, E> DynSend for LinkedGraph<N, E>
where N: DynSend, E: DynSend,

§

### impl<N, E> DynSync for LinkedGraph<N, E>
where N: DynSync, E: DynSync,

§

### impl<N, E> Freeze for LinkedGraph<N, E>

§

### impl<N, E> RefUnwindSafe for LinkedGraph<N, E>
where N: RefUnwindSafe, E: RefUnwindSafe,

§

### impl<N, E> Send for LinkedGraph<N, E>
where N: Send, E: Send,

§

### impl<N, E> Sync for LinkedGraph<N, E>
where N: Sync, E: Sync,

§

### impl<N, E> Unpin for LinkedGraph<N, E>
where N: Unpin, E: Unpin,

§

### impl<N, E> UnwindSafe for LinkedGraph<N, E>
where N: UnwindSafe, E: UnwindSafe,

## Blanket Implementations§

Source§

### impl<T> Aligned for T

Source§

#### const ALIGN: Alignment = const ALIGN: Alignment = Alignment::of::<Self>();

Alignment of `Self`.
§

### impl<T> Any for T
where T: 'static + ?Sized,

§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<T> Borrow<T> for T
where T: ?Sized,

§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

### impl<T> From<T> for T

§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
§

### impl<T, U> Into<U> for T
where U: From<T>,

§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

§

### impl<T> IntoEither for T

§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

### impl<T> Pointable for T

§

#### const ALIGN: usize

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more

## Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain `repr(...)` attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes