Struct CacheEntry 

pub struct CacheEntry {
    pub directives: Vec<Spanned<Directive>>,
    pub options: CachedOptions,
    pub plugins: Vec<CachedPlugin>,
    pub files: Vec<String>,
}

Complete cache entry containing all data needed to restore a LoadResult.

Fields

directives: Vec<Spanned<Directive>>

All parsed directives.

options: CachedOptions

Parsed options.

plugins: Vec<CachedPlugin>

Plugin declarations.

files: Vec<String>

All files that were loaded (as strings, for serialization).

Implementations

impl CacheEntry

pub fn file_paths(&self) -> Vec<PathBuf>

Get files as PathBuf references.

pub fn into_load_result(self) -> LoadResult

Reconstruct a LoadResult equivalent to a fresh parse of the cached source.

Re-reads each cached source file for the source map (so error reporting still has text), converts the cached plugin declarations back (their span / file_id are not meaningful from cache), and — crucially — rebuilds the display context from the cached directives + options via the same inference a fresh load uses, so a cache-hit LoadResult formats numbers identically to an uncached one. Reconstructing it as an empty DisplayContext (as the per-command CLI code used to) would silently change per-currency display precision for any consumer that reads it.

errors is empty by construction: the cache is only written for error-free, warning-free loads.

Strings are NOT re-interned here; a caller that wants the memory dedup should call crate::reintern_directives on self.directives first (it needs &mut).

Trait Implementations

impl Archive for CacheEntry

where Vec<Spanned<Directive>>: Archive, CachedOptions: Archive, Vec<CachedPlugin>: Archive, Vec<String>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedCacheEntry

The archived representation of this type.

type Resolver = CacheEntryResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for CacheEntry

fn clone(&self) -> CacheEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheEntry

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<CacheEntry, __D> for Archived<CacheEntry>

where Vec<Spanned<Directive>>: Archive, <Vec<Spanned<Directive>> as Archive>::Archived: Deserialize<Vec<Spanned<Directive>>, __D>, CachedOptions: Archive, <CachedOptions as Archive>::Archived: Deserialize<CachedOptions, __D>, Vec<CachedPlugin>: Archive, <Vec<CachedPlugin> as Archive>::Archived: Deserialize<Vec<CachedPlugin>, __D>, Vec<String>: Archive, <Vec<String> as Archive>::Archived: Deserialize<Vec<String>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<CacheEntry, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for CacheEntry

where Vec<Spanned<Directive>>: Serialize<__S>, CachedOptions: Serialize<__S>, Vec<CachedPlugin>: Serialize<__S>, Vec<String>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.