Struct CurrentCellRef 

pub struct CurrentCellRef { /* private fields */ }

A reference to a task’s cell with methods that allow updating the contents of the cell.

Mutations should not outside of the task that that owns this cell. Doing so is a logic error, and may lead to incorrect caching behavior.

Implementations

impl CurrentCellRef

pub fn compare_and_update<T>(&self, new_value: T)

where T: PartialEq + VcValueType,

Replace the current cell’s content with new_value if the current content is not equal by value with the existing content.

The comparison happens using the value itself, not the VcRead::Target of that value.

Take this example of a custom equality implementation on a transparent wrapper type:

#[turbo_tasks::value(transparent, eq = "manual")]
struct Wrapper(Vec<u32>);

impl PartialEq for Wrapper {
    fn eq(&self, other: Wrapper) {
        // Example: order doesn't matter for equality
        let (mut this, mut other) = (self.clone(), other.clone());
        this.sort_unstable();
        other.sort_unstable();
        this == other
    }
}

impl Eq for Wrapper {}

Comparisons of Vc<Wrapper> used when updating the cell will use Wrapper’s custom equality implementation, rather than the one provided by the target (Vec<u32>) type.

However, in most cases, the default derived implementation of PartialEq is used which just forwards to the inner value’s PartialEq.

If you already have a SharedReference, consider calling Self::compare_and_update_with_shared_reference which can re-use the SharedReference object.

pub fn compare_and_update_with_shared_reference<T>( &self, new_shared_reference: SharedReference, )

where T: VcValueType + PartialEq,

Replace the current cell’s content with new_shared_reference if the current content is not equal by value with the existing content.

If you already have a SharedReference, this is a faster version of CurrentCellRef::compare_and_update.

The value should be stored in SharedReference using the type T.

pub fn keyed_compare_and_update<T>(&self, new_value: T)

where T: PartialEq + VcValueType, <<T as VcValueType>::Read as VcRead<T>>::Target: Keyed, <<<T as VcValueType>::Read as VcRead<T>>::Target as Keyed>::Key: Hash,

See Self::compare_and_update, but selectively update individual keys.

pub fn keyed_compare_and_update_with_shared_reference<T>( &self, new_shared_reference: SharedReference, )

where T: VcValueType + PartialEq, <<T as VcValueType>::Read as VcRead<T>>::Target: Keyed, <<<T as VcValueType>::Read as VcRead<T>>::Target as Keyed>::Key: Hash,

See Self::compare_and_update_with_shared_reference, but selectively update individual keys.

pub fn update<T>(&self, new_value: T, verification_mode: VerificationMode)

where T: VcValueType,

Unconditionally updates the content of the cell.

pub fn update_with_shared_reference( &self, shared_ref: SharedReference, verification_mode: VerificationMode, )

A faster version of Self::update if you already have a SharedReference.

If the passed-in SharedReference is the same as the existing cell’s by identity, no update is performed.

The value should be stored in SharedReference using the type T.

Trait Implementations

impl Clone for CurrentCellRef

fn clone(&self) -> CurrentCellRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl From<CurrentCellRef> for RawVc

fn from(cell: CurrentCellRef) -> Self

Converts to this type from the input type.

impl Copy for CurrentCellRef