Struct OperationVc 

pub struct OperationVc<T>
where
    T: ?Sized,
{ /* private fields */ }

A “subtype” (can be converted via .connect()) of Vc that represents a specific call (with arguments) to a task.

Unlike Vc, OperationVc:

• Does not potentially refer to task-local information, meaning that it implements NonLocalValue, and can be used in any #[turbo_tasks::value].

• Has only one potential internal representation, meaning that it has a saner equality definition.

• Can be reconnected to the strongly-consistent compilation graph after being placed inside of a State.

• Makes sense with collectibles, as it represents a function call, and only function calls can have issues or side-effects.

Equality & Hashing

Equality between two OperationVcs means that both have an identical in-memory representation and point to the same task function call. The implementation of Hash has similar behavior.

If connected and then .awaited at the same time, both would likely resolve to the same ReadRef, though it is possible that they may not if the task or cell is invalidated between .awaits.

Because equality is a synchronous operation that cannot read the cell contents, even if the OperationVcs are not equal, it is possible that if .awaited, both OperationVcs could point to the same or equal values.

Implementations

impl<T: ?Sized> OperationVc<T>

pub fn connect(self) -> Vc<T>

Marks this operation’s underlying function call as a child of the current task, and returns a Vc that can be resolved or read with .await?.

By marking this function call as a child of the current task, turbo-tasks will re-run tasks as-needed to achieve strong consistency at the root of the function call tree. This explicit operation is needed as OperationVc types can be stored outside of the call graph as part of States.

pub fn into_raw(vc: Self) -> RawVc

Returns the RawVc corresponding to this Vc.

pub fn upcast<K>(vc: Self) -> OperationVc<K>

where T: UpcastStrict<K>, K: VcValueTrait + ?Sized,

Upcasts the given OperationVc<T> to a OperationVc<Box<dyn K>>.

This is also available as an Into/From conversion.

pub async fn resolve_strongly_consistent(self) -> Result<ResolvedVc<T>>

Connects the OperationVc and resolves the reference until it points to a cell directly in a strongly consistent way.

Resolving will wait for task execution to be finished, so that the returned ResolvedVc points to a cell that stores a value.

Resolving is necessary to compare identities of Vcs.

This is async and will rethrow any fatal error that happened during task execution.

pub fn read_strongly_consistent(self) -> ReadVcFuture<T>

where T: VcValueType,

Connects the OperationVc and returns a strongly consistent read of the value.

This ensures that all internal tasks are finished before the read is returned.

Trait Implementations

impl<T> Clone for OperationVc<T>

where T: ?Sized,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> CollectiblesSource for OperationVc<T>

where T: ?Sized,

fn drop_collectibles<Vt: VcValueTrait>(self)

fn take_collectibles<Vt: VcValueTrait>(self) -> AutoSet<ResolvedVc<Vt>>

fn peek_collectibles<Vt: VcValueTrait>(self) -> AutoSet<ResolvedVc<Vt>>

impl<T> Debug for OperationVc<T>

where T: ?Sized,

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

Formats the value using the given formatter.

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

where T: ?Sized,

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T> Hash for OperationVc<T>

where T: ?Sized,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for OperationVc<T>

where T: ?Sized,

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 OperationVc<T>

where T: ?Sized,

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T> TaskInput for OperationVc<T>

where T: ?Sized + Send + Sync,

fn is_transient(&self) -> bool

fn resolve_input(&self) -> impl Future<Output = Result<Self>> + Send + '_

fn is_resolved(&self) -> bool

impl<T> TraceRawVcs for OperationVc<T>

where T: ?Sized,

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

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

impl<T> TryFrom<RawVc> for OperationVc<T>

where T: ?Sized,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(raw: RawVc) -> Result<Self>

Performs the conversion.

impl<T> Copy for OperationVc<T>

where T: ?Sized,

impl<T> Eq for OperationVc<T>

where T: ?Sized,

impl<T: NonLocalValue + ?Sized> NonLocalValue for OperationVc<T>

impl<T: ?Sized + Send> OperationValue for OperationVc<T>