Struct WriteVar

pub struct WriteVar<T: Serialize + DeserializeOwned, C = VarNotClaimed> { /* private fields */ }

Write a value into a flowey Var at runtime, which can then be read via a corresponding ReadVar.

Vars in flowey must be serde de/serializable, in order to be de/serialized between multiple steps/nodes.

In order to write a value into a WriteVar, it must first be claimed by a particular step (using the ClaimVar::claim API). Once claimed, the Var can be written to using APIs such as RustRuntimeServices::write, or AdoStepServices::set_var

Note that it is only possible to write a value into a WriteVar once. Once the value has been written, the WriteVar type is immediately consumed, making it impossible to overwrite the stored value at some later point in execution.

This “write-once” property is foundational to flowey’s execution model, as by recoding what step wrote to a Var, and what step(s) read from the Var, it is possible to infer what order steps must be run in.

Implementations

impl<T: Serialize + DeserializeOwned> WriteVar<T, VarNotClaimed>

pub fn new_reader(&self) -> ReadVar<T>

Create a new ReadVar from this WriteVar handle.

pub fn write_static(self, ctx: &mut NodeCtx<'_>, val: T)

where T: 'static,

Write a static value into the Var.

impl<T: Serialize + DeserializeOwned, C> WriteVar<T, C>

pub fn is_secret(&self) -> bool

Return whether the WriteVar is a secret.

Trait Implementations

impl<T: Serialize + DeserializeOwned> ClaimVar for WriteVar<T>

type Claimed = WriteVar<T, VarClaimed>

The claimed version of Self.

fn claim(self, ctx: &mut StepCtx<'_>) -> ClaimedWriteVar<T>

Claim the Var for this step, allowing it to be accessed at runtime.

impl<T: Debug + Serialize + DeserializeOwned, C: Debug> Debug for WriteVar<T, C>

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

Formats the value using the given formatter.

impl<'de, T: Serialize + DeserializeOwned, C> Deserialize<'de> for WriteVar<T, C>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Serialize + DeserializeOwned, C> Serialize for WriteVar<T, C>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> VarEqBacking for WriteVar<T>

where T: Serialize + DeserializeOwned,

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

Check if self is backed by the same variable as other.