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 conditional_update<T>( &self, functor: impl FnOnce(Option<&T>) -> Option<T>, )

where T: VcValueType,

Updates the cell if the given functor returns a value.

pub fn conditional_update_with_shared_reference( &self, functor: impl FnOnce(Option<&SharedReference>) -> Option<SharedReference>, )

Updates the cell if the given functor returns a SharedReference.

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 SharedReference is expected to use the <T::Read as VcRead<T>>::Repr type for its representation of the value.

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

where T: VcValueType,

Unconditionally updates the content of the cell.

pub fn update_with_shared_reference(&self, shared_ref: SharedReference)

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 SharedReference is expected to use the <T::Read as VcRead<T>>::Repr type for its representation of the value.

Trait Implementations

impl Clone for CurrentCellRef

fn clone(&self) -> CurrentCellRef

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for CurrentCellRef

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CurrentCellRef> for RawVc

fn from(cell: CurrentCellRef) -> Self

Converts to this type from the input type.

impl Serialize for CurrentCellRef

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for CurrentCellRef