Struct ResolvedVc

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

A “subtype” (via Deref) of Vc that represents a specific Vc::cell/.cell() or ResolvedVc::cell/.resolved_cell() constructor call within a task.

Unlike Vc, ResolvedVc:

• 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.

• Points to a concrete value with a type, and is therefore cheap to downcast.

Construction

There are a few ways to construct a ResolvedVc, in order of preference:

1. Given a value, construct a ResolvedVc using ResolvedVc::cell (for “transparent” values) or by calling the generated .resolved_cell() constructor on the value type.

2. Given an argument to a function using the #[turbo_tasks::function] macro, change the argument’s type to a ResolvedVc. The rewritten external signature will still use Vc, but when the function is called, the Vc will be resolved.

3. Given a Vc, use .to_resolved().await?.

Equality & Hashing

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

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

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

Implementations

impl<T> ResolvedVc<T>

where T: ?Sized,

pub async fn to_resolved(self) -> Result<Self>

👎Deprecated: No point in resolving a vc that is already resolved

This function exists to intercept calls to Vc::to_resolved through dereferencing a ResolvedVc. Converting to Vc and re-resolving it puts unnecessary stress on the turbo tasks engine.

pub async fn resolve(self) -> Result<Vc<T>>

👎Deprecated: No point in resolving a vc that is already resolved

impl<T, Inner, Repr> ResolvedVc<T>

where T: VcValueType<Read = VcTransparentRead<T, Inner, Repr>>, Inner: Any + Send + Sync, Repr: VcValueType,

pub fn cell(inner: Inner) -> Self

impl<T> ResolvedVc<T>

where T: ?Sized,

pub fn upcast<K>(this: Self) -> ResolvedVc<K>

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

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

See also: Vc::upcast.

pub fn deref_vec(vec: Vec<ResolvedVc<T>>) -> Vec<Vc<T>>

Cheaply converts a Vec of resolved Vcs to a Vec of Vcs.

pub fn deref_slice(slice: &[ResolvedVc<T>]) -> &[Vc<T>]

Cheaply converts a slice of resolved Vcs to a slice of Vcs.

impl<T> ResolvedVc<T>

where T: VcValueTrait + ?Sized,

pub fn try_sidecast<K>(this: Self) -> Option<ResolvedVc<K>>

where K: VcValueTrait + ?Sized,

Returns None if the underlying value type does not implement K.

Note: if the trait T is required to implement K, use ResolvedVc::upcast instead. This provides stronger guarantees, removing the need for a Result return type.

See also: Vc::try_resolve_sidecast.

pub fn try_downcast<K>(this: Self) -> Option<ResolvedVc<K>>

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

Attempts to downcast the given ResolvedVc<Box<dyn T>> to a ResolvedVc<K>, where K is of the form Box<dyn L>, and L is a value trait.

Returns None if the underlying value type is not a K.

See also: Vc::try_resolve_downcast.

pub fn try_downcast_type<K>(this: Self) -> Option<ResolvedVc<K>>

where K: Upcast<T> + VcValueType,

Attempts to downcast the given Vc<Box<dyn T>> to a Vc<K>, where K is a value type.

Returns None if the underlying value type is not a K.

See also: Vc::try_resolve_downcast_type.

Trait Implementations

impl<T> Clone for ResolvedVc<T>

where T: ?Sized,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ResolvedVc<T>

where T: ?Sized,

Generates an opaque debug representation of the ResolvedVc itself, but not the data inside of it.

This is implemented to allow types containing ResolvedVc to implement the synchronous Debug trait, but in most cases users should use the ValueDebug implementation to get a string representation of the contents of the cell.

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

Formats the value using the given formatter.

impl<T, Inner, Repr> Default for ResolvedVc<T>

where T: VcValueType<Read = VcTransparentRead<T, Inner, Repr>>, Inner: Any + Send + Sync + Default, Repr: VcValueType,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for ResolvedVc<T>

where T: ?Sized,

type Target = Vc<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

where T: ?Sized,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> FromTaskInput for ResolvedVc<T>

where T: Send + Sync + ?Sized,

type TaskInput = Vc<T>

fn from_task_input(from: Vc<T>) -> ResolvedVc<T>

impl<T> Hash for ResolvedVc<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> IntoFuture for &ResolvedVc<T>

where T: VcValueType,

type Output = <Vc<T> as IntoFuture>::Output

The output that the future will produce on completion.

type IntoFuture = <Vc<T> as IntoFuture>::IntoFuture

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<T> IntoFuture for &mut ResolvedVc<T>

where T: VcValueType,

type Output = <Vc<T> as IntoFuture>::Output

The output that the future will produce on completion.

type IntoFuture = <Vc<T> as IntoFuture>::IntoFuture

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<T> IntoFuture for ResolvedVc<T>

where T: VcValueType,

type Output = <Vc<T> as IntoFuture>::Output

The output that the future will produce on completion.

type IntoFuture = <Vc<T> as IntoFuture>::IntoFuture

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<T> PartialEq for ResolvedVc<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 ResolvedVc<T>

where T: ?Sized,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> TaskInput for ResolvedVc<T>

where T: Send + Sync + ?Sized,

fn is_resolved(&self) -> bool

fn is_transient(&self) -> bool

async fn resolve_input(&self) -> Result<Self>

impl<T> TraceRawVcs for ResolvedVc<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 ResolvedVc<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> ValueDebugFormat for ResolvedVc<T>

where T: Upcast<Box<dyn ValueDebug>> + Send + Sync + ?Sized,

fn value_debug_format(&self, depth: usize) -> ValueDebugFormatString<'_>

impl<T> Copy for ResolvedVc<T>

where T: ?Sized,

impl<T> Eq for ResolvedVc<T>

where T: ?Sized,

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