Enum State 

pub enum State<V, R, E> {
    Ok(Generator<V, R>),
    Suspended(SuspendedGenerator<V, R>, E),
}

Generator states which may occur after a call to try_write_next.

If you want to abort on an error, use halt_if_suspended. If you want to continue despite the error, use SuspendedGenerator::resume.

Variants

Ok(Generator<V, R>)

The vertex was written successfully.

Suspended(SuspendedGenerator<V, R>, E)

The vertex was not written because of an error.

Implementations

impl<V, R, E> State<V, R, E>

pub fn halt_if_suspended(self) -> Result<Generator<V, R>, E>

Return the generator if ok, or drop the suspended generator and return the error if not.

pub fn try_write_next<I, F, W>( self, writer: &mut W, f: F, ) -> Result<State<V, R, R::Error>, W::Error>

where R: TryRamify<V>, I: IntoIterator<Item = V>, F: FnOnce(E) -> I, W: DiagramWrite,

Either write the next vertex or resume from the suspended state with a closure.

If this is a State::Ok, this calls Generator::try_write_next, and if this is a State::Suspended, the provided closure is applied to the error to provide a new list of children.

pub fn try_write_all<I, F, W>( self, writer: &mut W, f: F, ) -> Result<(), W::Error>

where R: TryRamify<V, Error = E>, I: IntoIterator<Item = V>, F: FnMut(E) -> I, W: DiagramWrite,

A convenience function to repeatedly try to write the next vertex or resume from the suspended state with a closure.

Note that instead of using this method, it may be possible to directly implement Ramify by inlining the closure into try_ramify and instead using Generator::write_all.

pub fn is_empty(&self) -> bool

Whether or not there are any active vertices.

If this is a State::Ok, this checks if the generator is non-empty, and if this is State::Suspended it always returns false since there is at least one active vertex.

pub fn into_active_vertices(self) -> impl ExactSizeIterator<Item = V>

Consume the state, returning an iterator over the active vertices in an unspecified order.