Struct State 

pub struct State {

    pub active: i32,
    pub current_tasks: Vec<i32>,
    pub current_flows: Vec<i32>,
    pub visited_tasks: Vec<i32>,
    pub visited_flows: Vec<i32>,
    pub pending_tasks: Vec<i32>,
    pub maybe_future_tasks: Vec<i32>,
    pub maybe_future_flows: Vec<i32>,
    pub maybe_visited_tasks: Vec<i32>,
    pub variables: JsonValue,
    pub completed: bool,
    pub remote_id: Option<String>,
    pub remote_version: Option<i64>,
}

Fields

active: i32

current_tasks: Vec<i32>

current_flows: Vec<i32>

visited_tasks: Vec<i32>

visited_flows: Vec<i32>

pending_tasks: Vec<i32>

maybe_future_tasks: Vec<i32>

maybe_future_flows: Vec<i32>

maybe_visited_tasks: Vec<i32>

variables: JsonValue

completed: bool

remote_id: Option<String>

remote_version: Option<i64>

Trait Implementations

impl Archive for State

where i32: Archive, Vec<i32>: Archive, JsonValue: Archive, bool: Archive, Option<String>: Archive, Option<i64>: Archive,

type Archived = ArchivedState

The archived representation of this type.

type Resolver = StateResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Debug for State

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

Formats the value using the given formatter.

impl<__D> Deserialize<State, __D> for Archived<State>

where __D: SharedDeserializeRegistry + Fallible + ?Sized, i32: Archive, Archived<i32>: Deserialize<i32, __D>, Vec<i32>: Archive, Archived<Vec<i32>>: Deserialize<Vec<i32>, __D>, JsonValue: Archive, Archived<JsonValue>: Deserialize<JsonValue, __D>, bool: Archive, Archived<bool>: Deserialize<bool, __D>, Option<String>: Archive, Archived<Option<String>>: Deserialize<Option<String>, __D>, Option<i64>: Archive, Archived<Option<i64>>: Deserialize<Option<i64>, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<State, __D::Error>

Deserializes using the given deserializer

impl<__S> Serialize<__S> for State

where __S: ScratchSpace + SharedSerializeRegistry + Serializer + Fallible + ?Sized, i32: Serialize<__S>, Vec<i32>: Serialize<__S>, JsonValue: Serialize<__S>, bool: Serialize<__S>, Option<String>: Serialize<__S>, Option<i64>: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.