pub(crate) struct Cache {Show 20 fields
pub(crate) impls: FxHashMap<DefId, Vec<Impl>>,
pub(crate) paths: FxHashMap<DefId, (Vec<Symbol>, ItemType)>,
pub(crate) external_paths: FxHashMap<DefId, (Vec<Symbol>, ItemType)>,
pub(crate) exact_paths: FxHashMap<DefId, Vec<Symbol>>,
pub(crate) traits: FxHashMap<DefId, TraitWithExtraInfo>,
pub(crate) implementors: FxHashMap<DefId, Vec<Impl>>,
pub(crate) extern_locations: FxHashMap<CrateNum, ExternalLocation>,
pub(crate) primitive_locations: FxHashMap<PrimitiveType, DefId>,
pub(crate) access_levels: AccessLevels<DefId>,
pub(crate) crate_version: Option<String>,
pub(crate) document_private: bool,
pub(crate) masked_crates: FxHashSet<CrateNum>,
stack: Vec<Symbol>,
parent_stack: Vec<ParentStackItem>,
stripped_mod: bool,
pub(crate) search_index: Vec<IndexItem>,
pub(crate) orphan_impl_items: Vec<OrphanImplItem>,
orphan_trait_impls: Vec<(DefId, FxHashSet<DefId>, Impl)>,
pub(crate) intra_doc_links: FxHashMap<ItemId, Vec<ItemLink>>,
pub(crate) hidden_cfg: FxHashSet<Cfg>,
}
Expand description
This cache is used to store information about the clean::Crate
being
rendered in order to provide more useful documentation. This contains
information like all implementors of a trait, all traits a type implements,
documentation for all known traits, etc.
This structure purposefully does not implement Clone
because it’s intended
to be a fairly large and expensive structure to clone. Instead this adheres
to Send
so it may be stored in an Arc
instance and shared among the various
rendering threads.
Fields
impls: FxHashMap<DefId, Vec<Impl>>
Maps a type ID to all known implementations for that type. This is only
recognized for intra-crate clean::Type::Path
s, and is used to print
out extra documentation on the page of an enum/struct.
The values of the map are a list of implementations and documentation found on that implementation.
paths: FxHashMap<DefId, (Vec<Symbol>, ItemType)>
Maintains a mapping of local crate DefId
s to the fully qualified name
and “short type description” of that node. This is used when generating
URLs when a type is being linked to. External paths are not located in
this map because the External
type itself has all the information
necessary.
external_paths: FxHashMap<DefId, (Vec<Symbol>, ItemType)>
Similar to paths
, but only holds external paths. This is only used for
generating explicit hyperlinks to other crates.
exact_paths: FxHashMap<DefId, Vec<Symbol>>
Maps local DefId
s of exported types to fully qualified paths.
Unlike ‘paths’, this mapping ignores any renames that occur
due to ‘use’ statements.
This map is used when writing out the special ‘implementors’ javascript file. By using the exact path that the type is declared with, we ensure that each path will be identical to the path used if the corresponding type is inlined. By doing this, we can detect duplicate impls on a trait page, and only display the impl for the inlined type.
traits: FxHashMap<DefId, TraitWithExtraInfo>
This map contains information about all known traits of this crate. Implementations of a crate should inherit the documentation of the parent trait if no extra documentation is specified, and default methods should show up in documentation about trait implementations.
implementors: FxHashMap<DefId, Vec<Impl>>
When rendering traits, it’s often useful to be able to list all implementors of the trait, and this mapping is exactly, that: a mapping of trait ids to the list of known implementors of the trait
extern_locations: FxHashMap<CrateNum, ExternalLocation>
Cache of where external crate documentation can be found.
primitive_locations: FxHashMap<PrimitiveType, DefId>
Cache of where documentation for primitives can be found.
access_levels: AccessLevels<DefId>
crate_version: Option<String>
The version of the crate being documented, if given from the --crate-version
flag.
document_private: bool
Whether to document private items.
This is stored in Cache
so it doesn’t need to be passed through all rustdoc functions.
masked_crates: FxHashSet<CrateNum>
Crates marked with #[doc(masked)]
.
stack: Vec<Symbol>
parent_stack: Vec<ParentStackItem>
stripped_mod: bool
search_index: Vec<IndexItem>
orphan_impl_items: Vec<OrphanImplItem>
orphan_trait_impls: Vec<(DefId, FxHashSet<DefId>, Impl)>
intra_doc_links: FxHashMap<ItemId, Vec<ItemLink>>
All intra-doc links resolved so far.
Links are indexed by the DefId of the item they document.
Cfg that have been hidden via #![doc(cfg_hide(…))]
Implementations
sourceimpl Cache
impl Cache
pub(crate) fn new(
access_levels: AccessLevels<DefId>,
document_private: bool
) -> Self
sourcepub(crate) fn populate(cx: &mut DocContext<'_>, krate: Crate) -> Crate
pub(crate) fn populate(cx: &mut DocContext<'_>, krate: Crate) -> Crate
Populates the Cache
with more data. The returned Crate
will be missing some data that was
in krate
due to the data being moved into the Cache
.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Cache
impl !Send for Cache
impl !Sync for Cache
impl Unpin for Cache
impl !UnwindSafe for Cache
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
Layout
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.
Size: 536 bytes