Struct PendingTask 

pub struct PendingTask<S: State> {
    pub id: String,
    pub node_name: String,
    pub trigger: TaskTrigger,
    pub state_override: Option<S>,
    pub state_json: Option<Value>,
    pub triggered_fields: Vec<usize>,
}

Pending task for execution

Represents a node that has been scheduled for execution in the next superstep.

Fields

id: String

Unique task identifier

node_name: String

Name of the node to execute

trigger: TaskTrigger

What triggered this task

state_override: Option<S>

Optional state override for this task (as JSON for Send operations)

state_json: Option<Value>

Optional state override as JSON (for Send operations)

Stored separately because Send operations provide state as serde_json::Value, which can’t be deserialized to S without S: DeserializeOwned bound. This is deserialized during task execution in the runner.

triggered_fields: Vec<usize>

Field indices that triggered this task

Tracks which specific fields had updates that caused this task to be scheduled. This allows fine-grained consumption of only triggered channels instead of consuming all changed fields.

Implementations

impl<S: State> PendingTask<S>

pub const fn new( id: String, node_name: String, trigger: TaskTrigger, state_override: Option<S>, triggered_fields: Vec<usize>, ) -> Self

Create a new pending task

Examples

use juncture_core::pregel::types::{PendingTask, TaskTrigger};
use juncture_core::State;

let task = PendingTask::<MyState> {
    id: "task-123".to_string(),
    node_name: "my_node".to_string(),
    trigger: TaskTrigger::Pull,
    state_override: None,
    state_json: None,
    triggered_fields: vec![],
};

pub const fn pull(id: String, node_name: String) -> Self

Create a pull-based task

pub const fn pull_with_triggered( id: String, node_name: String, triggered_fields: Vec<usize>, ) -> Self

Create a pull-based task with triggered fields

pub const fn push( id: String, node_name: String, index: usize, state_json: Value, ) -> Self

Create a push-based task with state override as JSON

This is used for Send operations where the state override comes from SendTarget.state (a serde_json::Value).

pub const fn push_typed( id: String, node_name: String, index: usize, state_override: S, ) -> Self

Create a push-based task with typed state override

This variant is used when the state override is already available as the typed state S (not just JSON).

Trait Implementations

impl<S: Clone + State> Clone for PendingTask<S>

fn clone(&self) -> PendingTask<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + State> Debug for PendingTask<S>

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

Formats the value using the given formatter.