Struct rustdoc::html::render::CacheUnstable [-] [+] [src]

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, ExternalLocation>,
    pub primitive_locations: HashMap<PrimitiveType, CrateNum>,
    pub inlined: HashSet<DefId>,
    // some fields omitted
}

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

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

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

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

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

traits

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

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

Cache of where external crate documentation can be found.

primitive_locations

Cache of where documentation for primitives can be found.

inlined

Set of definitions which have been inlined from external crates.

Trait Implementations

impl DocFolder for Cache

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

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

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