Struct rustdoc::html::render::Cache

pub struct Cache {
    pub typarams: HashMap<DefId, String>,
    pub impls: HashMap<DefId, Vec<Impl>>,
    pub paths: HashMap<DefId, (Vec<String>, ItemType)>,
    pub external_paths: HashMap<DefId, Vec<String>>,
    pub traits: HashMap<DefId, Trait>,
    pub implementors: HashMap<DefId, Vec<Implementor>>,
    pub extern_locations: HashMap<CrateNum, (String, ExternalLocation)>,
    pub primitive_locations: HashMap<PrimitiveType, CrateNum>,
    pub inlined: HashSet<DefId>,
    pub access_levels: Arc<AccessLevels<DefId>>,
    // some fields omitted
}

Unstable (rustdoc)

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 a Arc instance and shared among the various rendering threads.

Fields

typarams: HashMap<DefId, String>

Unstable (rustdoc)

Mapping of typaram ids to the name of the type parameter. This is used when pretty-printing a type (so pretty printing doesn't have to painfully maintain a context like this)

impls: HashMap<DefId, Vec<Impl>>

Unstable (rustdoc)

Maps a type id to all known implementations for that type. This is only recognized for intra-crate ResolvedPath types, 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: HashMap<DefId, (Vec<String>, ItemType)>

Unstable (rustdoc)

Maintains a mapping of local crate node ids 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: HashMap<DefId, Vec<String>>

Unstable (rustdoc)

Similar to paths, but only holds external paths. This is only used for generating explicit hyperlinks to other crates.

traits: HashMap<DefId, Trait>

Unstable (rustdoc)

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: HashMap<DefId, Vec<Implementor>>

Unstable (rustdoc)

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: HashMap<CrateNum, (String, ExternalLocation)>

Unstable (rustdoc)

Cache of where external crate documentation can be found.

primitive_locations: HashMap<PrimitiveType, CrateNum>

Unstable (rustdoc)

Cache of where documentation for primitives can be found.

inlined: HashSet<DefId>

Unstable (rustdoc)

Set of definitions which have been inlined from external crates.

access_levels: Arc<AccessLevels<DefId>>

Unstable (rustdoc)

Trait Implementations

impl DocFolder for Cache

fn fold_item(&mut self, item: Item) -> Option<Item>

fn fold_inner_recur(&mut self, inner: ItemEnum) -> ItemEnum

don't override!

fn fold_item_recur(&mut self, item: Item) -> Option<Item>

don't override!

fn fold_mod(&mut self, m: Module) -> Module

fn fold_crate(&mut self, c: Crate) -> Crate

Derived Implementations

impl Default for Cache

fn default() -> Cache

Returns the "default value" for a type.