Struct CachedTaskType 

pub struct CachedTaskType {
    pub native_fn: &'static NativeFunction,
    pub this: Option<RawVc>,
    pub arg: Box<dyn DynTaskInputs>,
}

A normal task execution containing a native (rust) function. This type is passed into the backend either to execute a function or to look up a cached result.

Fields

native_fn: &'static NativeFunction

this: Option<RawVc>

arg: Box<dyn DynTaskInputs>

Implementations

impl CachedTaskType

pub fn get_name(&self) -> &'static str

Get the name of the function. Equivalent to the Display/ToString::to_string implementation, but does not allocate a String.

pub fn hash_encode<H: DeterministicHasher>(&self, hasher: &mut H)

Encodes this task type directly to a hasher, avoiding buffer allocation.

This uses the same encoding logic as TurboBincodeEncode but writes directly to a DeterministicHasher instead of a buffer.

impl CachedTaskType

pub fn hash_from_components( hasher: &impl BuildHasher, native_fn: &'static NativeFunction, this: Option<RawVc>, arg: &dyn DynTaskInputs, ) -> u64

Compute the hash of a task type from its individual components, matching the Hash impl. This avoids constructing a full CachedTaskType just to compute the hash.

pub fn hash_encode_components<H: DeterministicHasher>( native_fn: &'static NativeFunction, this: Option<RawVc>, arg: &dyn DynTaskInputs, hasher: &mut H, )

Compute the deterministic hash for backing storage from components.

This mirrors the logic in CachedTaskType::hash_encode but works with borrowed components, avoiding the need to construct a full CachedTaskType.

pub fn eq_components( &self, native_fn: &'static NativeFunction, this: Option<RawVc>, arg: &dyn DynTaskInputs, ) -> bool

Check equality of components against this CachedTaskType.

Trait Implementations

impl AsRef<CachedTaskType> for CachedTaskTypeArc

fn as_ref(&self) -> &CachedTaskType

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<CachedTaskType> for CachedTaskTypeArc

fn borrow(&self) -> &CachedTaskType

Immutably borrows from an owned value.

impl<'de, __Context> BorrowDecode<'de, __Context> for CachedTaskType

fn borrow_decode<D: BorrowDecoder<'de, Context = __Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Debug for CachedTaskType

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

Formats the value using the given formatter.

impl<Context> Decode<Context> for CachedTaskType

fn decode<D: Decoder<Context = Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Display for CachedTaskType

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

Formats the value using the given formatter.

impl Encode for CachedTaskType

fn encode<'a, E: Encoder>(&self, encoder: &'a mut E) -> Result<(), EncodeError>

Encode a given type.

impl Hash for CachedTaskType

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 PartialEq for CachedTaskType

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<Context> TurboBincodeDecode<Context> for CachedTaskType

fn decode(decoder: &mut TurboBincodeDecoder<'_>) -> Result<Self, DecodeError>

impl TurboBincodeEncode for CachedTaskType

fn encode( &self, encoder: &mut TurboBincodeEncoder<'_>, ) -> Result<(), EncodeError>

impl Eq for CachedTaskType