Struct WriteVar

pub struct WriteVar<T, C = VarNotClaimed>
where
    T: Serialize + DeserializeOwned,
{ /* 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> WriteVar<T>

where T: Serialize + DeserializeOwned,

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, C> WriteVar<T, C>

where T: Serialize + DeserializeOwned,

pub fn is_secret(&self) -> bool

Return whether the WriteVar is a secret.

Trait Implementations

impl<T> ClaimVar for WriteVar<T>

where T: Serialize + DeserializeOwned,

type Claimed = WriteVar<T, VarClaimed>

The claimed version of Self.

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

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

impl<T, C> Debug for WriteVar<T, C>

where T: Debug + Serialize + DeserializeOwned, C: Debug,

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

Formats the value using the given formatter.

impl<'de, T, C> Deserialize<'de> for WriteVar<T, C>

where T: Serialize + DeserializeOwned,

fn deserialize<__D>( __deserializer: __D, ) -> Result<WriteVar<T, C>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, C> Serialize for WriteVar<T, C>

where T: Serialize + DeserializeOwned,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::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: &WriteVar<T>) -> bool

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