Struct State 

pub struct State<T> { /* private fields */ }

This API violates core assumption of turbo-tasks, is believed to be unsound, and there’s no plan fix it. You should prefer to use collectibles instead of state where at all possible. This API may be removed in the future.

An internally-mutable type, similar to RefCell or [Mutex] that can be stored inside a VcValueType.

State should only be used with OperationVc and types that implement OperationValue.

Setting values inside a State bypasses the normal argument and return value tracking that’s tracks child function calls and re-runs tasks until their values settled. That system is needed for strong consistency. OperationVc ensures that function calls are reconnected with the parent/child call graph.

When reading a State with State::get, the state itself (though not any values inside of it) is marked as a dependency of the current task.

Implementations

impl<T> State<T>

pub fn new(value: T) -> Self

where T: OperationValue,

pub fn get(&self) -> StateRef<'_, T>

Gets the current value of the state. The current task will be registered as dependency of the state and will be invalidated when the state changes.

pub fn get_untracked(&self) -> StateRef<'_, T>

Gets the current value of the state. Untracked.

pub fn set_unconditionally(&self, value: T)

Sets the current state without comparing it with the old value. This should only be used if one is sure that the value has changed.

pub fn update_conditionally(&self, update: impl FnOnce(&mut T) -> bool)

Updates the current state with the update function. The update function need to return true when the value was modified. Exposing the current value from the update function is not allowed and will result in incorrect cache invalidation.

impl<T: PartialEq> State<T>

pub fn set(&self, value: T)

Update the current state when the value is different from the current value. T must implement PartialEq for this to work.

Trait Implementations

impl<T: Debug> Debug for State<T>

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

Formats the value using the given formatter.

impl<T: Default + OperationValue> Default for State<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for State<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> PartialEq for State<T>

fn eq(&self, _other: &Self) -> 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<T> Serialize for State<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: TraceRawVcs> TraceRawVcs for State<T>

fn trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext)

fn get_raw_vcs(&self) -> Vec<RawVc>

impl<T> Eq for State<T>

impl<T: NonLocalValue> NonLocalValue for State<T>

impl<T: OperationValue> OperationValue for State<T>