Enum WalkReturn

source

enum WalkReturn<S, A> {
    Cycle {
        min_depth: usize,
        annotation: A,
    },
    Complete {
        scc_index: S,
        annotation: A,
    },
}

Expand description

The state of walking a given node.

Variants§

§

Cycle

The walk found a cycle, but the entire component is not known to have been fully walked yet. We only know the minimum depth of this component in a minimum spanning tree of the graph. This component is tentatively represented by the state of the first node of this cycle we met, which is at min_depth.

Fields

§min_depth: usize

§annotation: A

§

Complete

The SCC and everything reachable from it have been fully walked. At this point we know what is inside the SCC as we have visited every node reachable from it. The SCC can now be fully represented by its ID.

Fields

§scc_index: S

§annotation: A

Enum WalkReturnCopy item path

Variants§

Cycle

Fields

Complete

Fields

Trait Implementations§

impl<S: Clone, A: Clone> Clone for WalkReturn<S, A>

fn clone(&self) -> WalkReturn<S, A>

fn clone_from(&mut self, source: &Self)

impl<S: Debug, A: Debug> Debug for WalkReturn<S, A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<S: Copy, A: Copy> Copy for WalkReturn<S, A>

Auto Trait Implementations§

impl<S, A> Freeze for WalkReturn<S, A>where A: Freeze, S: Freeze,

impl<S, A> RefUnwindSafe for WalkReturn<S, A>where A: RefUnwindSafe, S: RefUnwindSafe,

impl<S, A> Send for WalkReturn<S, A>where A: Send, S: Send,

impl<S, A> Sync for WalkReturn<S, A>where A: Sync, S: Sync,

impl<S, A> Unpin for WalkReturn<S, A>where A: Unpin, S: Unpin,

impl<S, A> UnwindSafe for WalkReturn<S, A>where A: UnwindSafe, S: UnwindSafe,

Blanket Implementations§

impl<T> Aligned for T

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

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

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

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

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dst: *mut T)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

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

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

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

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

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

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

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

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

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

impl<T> WithSubscriber for T

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

fn with_current_subscriber(self) -> WithDispatch<Self>

impl<'a, T> Captures<'a> for Twhere T: ?Sized,

Layout§

Enum WalkReturn

impl<S, A> Freeze for WalkReturn<S, A>
where A: Freeze, S: Freeze,

impl<S, A> RefUnwindSafe for WalkReturn<S, A>
where A: RefUnwindSafe, S: RefUnwindSafe,

impl<S, A> Send for WalkReturn<S, A>
where A: Send, S: Send,

impl<S, A> Sync for WalkReturn<S, A>
where A: Sync, S: Sync,

impl<S, A> Unpin for WalkReturn<S, A>
where A: Unpin, S: Unpin,

impl<S, A> UnwindSafe for WalkReturn<S, A>
where A: UnwindSafe, S: UnwindSafe,

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

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

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

impl<T> CloneToUninit for T
where T: Clone,

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

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

impl<T> ToOwned for T
where T: Clone,

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

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

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

impl<'a, T> Captures<'a> for T
where T: ?Sized,