Enum Plan 

pub enum Plan {
    Empty,
    Execute {
        node: NodeId,
        from: Vec<NodeId>,
    },
    Sequence(Vec<Plan>),
    Wave(Vec<Plan>),
    Remote {
        host: Host,
        inner: Box<Plan>,
    },
}

How a graph is walked.

No #[non_exhaustive]: whoever executes has to decide for each variant.

Variants

Empty

Nothing to do.

Execute

Advance one node until it finishes.

Fields

node: NodeId

Which one.

from: Vec<NodeId>

Where its input comes from. Empty = the graph’s input.

Sequence(Vec<Plan>)

One after another, in topological order. Each reads what it needs from what has already been produced.

Wave(Vec<Plan>)

Branches launched at the same time, one per connected component, so they are disjoint. Each is a whole plan, so a branch runs start to finish on one thread.

Remote

This whole slice executes elsewhere. A complete plan and not a step, so a chain of five nodes on the same host is sent once.

Fields

host: Host

Where.

inner: Box<Plan>

What runs there.

Implementations

impl Plan

pub fn steps(&self) -> impl Iterator<Item = Step<'_>>

Every step, in declaration order, wherever it runs: a Remote is entered, because what a plan does does not depend on where.

pub fn destinations(&self) -> impl Iterator<Item = Destination<'_>>

What decides where each part of this plan runs, in declaration order. Differs from steps in one line: a Remote is not entered, which is what makes distribute idempotent.

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Plan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Plan

fn eq(&self, other: &Plan) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Plan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Plan

impl StructuralPartialEq for Plan