Enum ChunkGroupKey 

pub enum ChunkGroupKey {
    Entry(Vec<ResolvedVc<Box<dyn Module>>>),
    Async(ResolvedVc<Box<dyn Module>>),
    Isolated(ResolvedVc<Box<dyn Module>>),
    IsolatedMerged {
        parent: ChunkGroupId,
        merge_tag: RcStr,
    },
    Shared(ResolvedVc<Box<dyn Module>>),
    SharedMultiple(Vec<ResolvedVc<Box<dyn Module>>>),
    SharedMerged {
        parent: ChunkGroupId,
        merge_tag: RcStr,
    },
    Collected(ResolvedVc<Box<dyn Module>>),
}

See ChunkGroup for documentation

Variants

Entry(Vec<ResolvedVc<Box<dyn Module>>>)

Async(ResolvedVc<Box<dyn Module>>)

Isolated(ResolvedVc<Box<dyn Module>>)

IsolatedMerged

Fields

parent: ChunkGroupId

merge_tag: RcStr

Shared(ResolvedVc<Box<dyn Module>>)

SharedMultiple(Vec<ResolvedVc<Box<dyn Module>>>)

SharedMerged

Fields

parent: ChunkGroupId

merge_tag: RcStr

Collected(ResolvedVc<Box<dyn Module>>)

a module with an incoming collected edge

Implementations

impl ChunkGroupKey

pub async fn ident_str( &self, keys: &(impl Index<usize, Output = Self> + ?Sized), ) -> Result<String>

A stable identity of this chunk group, independent of the module graph it was discovered in.

The result contains only module idents and merge tags, never a ChunkGroupId, which is an index into one ChunkGroupInfo and denotes an unrelated chunk group in another: the parent of a merged chunk group is resolved through keys and rendered recursively.

crate::chunk::available_chunk_groups::AvailableChunkGroups::hash derives output file names from this, so two chunk groups must render equally exactly when they are the same chunk group. Changing the rendering renames assets; adding anything graph-local to it is a correctness bug.

pub async fn debug_str( &self, keys: &(impl Index<usize, Output = Self> + ?Sized), ) -> Result<String>

How this chunk group is shown in debug output.

Delegates to Self::ident_str, which already renders the chunk group unambiguously. Debug output is free to diverge from it, but note that ident_str must stay stable because asset idents are derived from it – change this wrapper rather than ident_str itself.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for ChunkGroupKey

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

Attempt to decode this type with the given BorrowDecode.

impl Clone for ChunkGroupKey

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChunkGroupKey

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for ChunkGroupKey

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

Attempt to decode this type with the given Decode.

impl Encode for ChunkGroupKey

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

Encode a given type.

impl Eq for ChunkGroupKey

impl Hash for ChunkGroupKey

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 NonLocalValue for ChunkGroupKey

impl PartialEq for ChunkGroupKey

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ChunkGroupKey

impl TaskInput for ChunkGroupKey

fn is_transient(&self) -> bool

This should return true if this object contains a Vc (or any subtype of Vc) pointing to a cell owned by a transient task.

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

This method should resolve any Vcs nested inside of this object, cloning the object in the process. If the input is unresolved (TaskInput::is_resolved) a “local” resolution task is created that runs this method.

fn is_resolved(&self) -> bool

This should return true if there are any unresolved Vcs in the type.