Struct ModuleItem

pub struct ModuleItem<'a> { /* private fields */ }

Implementations

impl<'a> ModuleItem<'a>

pub fn name(&self) -> &str

Examples found in repository

examples/items.rs (line 25)

fn main() {
    use crate_inspector::CrateBuilder;

    let builder = CrateBuilder::default()
        .toolchain("nightly")
        .manifest_path("Cargo.toml");
    let krate = builder.build().unwrap();

    for item in krate.items() {
        println!("item: {:?}", item.name);
    }
    for strc in krate.structs() {
        println!("struct: {}", strc.name());
        println!("#impls: {}", strc.impls().count());
    }
    for enm in krate.enums() {
        println!("enum: {}", enm.name());
        println!("variants: {:?}", enm.variants().collect::<Vec<_>>());
        println!(
            "#methods: {}",
            enm.impls().fold(0, |acc, i| acc + i.functions().count())
        );
    }
    for sub in krate.sub_modules() {
        println!("submodule: {}", sub.name());
    }
    if let Some(item) = krate.get_item("format") {
        println!("item: {:?}", item.id);
    }
}

pub fn item_ids(&self) -> impl Iterator<Item = &Id>

pub fn items(&self) -> impl Iterator<Item = &Item>

pub fn parent(&self) -> Option<ModuleItem<'a>>

impl<'a> ModuleItem<'a>

pub fn constants(&self) -> impl Iterator<Item = ConstantItem<'_>>

pub fn functions(&self) -> impl Iterator<Item = FunctionItem<'_>>

pub fn structs(&self) -> impl Iterator<Item = StructItem<'_>>

pub fn enums(&self) -> impl Iterator<Item = EnumItem<'_>>

pub fn traits(&self) -> impl Iterator<Item = TraitItem<'_>>

pub fn type_aliases(&self) -> impl Iterator<Item = TypeAliasItem<'_>>

pub fn trait_aliases(&self) -> impl Iterator<Item = TraitAliasItem<'_>>

pub fn unions(&self) -> impl Iterator<Item = UnionItem<'_>>

pub fn modules(&self) -> impl Iterator<Item = ModuleItem<'_>>

pub fn impls(&self) -> impl Iterator<Item = ImplItem<'_>>

pub fn uses(&self) -> impl Iterator<Item = UseItem<'_>>

pub fn get_item(&self, name: &str) -> Option<&Item>

Get an item by its name.

pub fn get_constant(&self, name: &str) -> Option<ConstantItem<'_>>

Get a constant by its name.

pub fn get_function(&self, name: &str) -> Option<FunctionItem<'_>>

Get a function by its name.

pub fn get_struct(&self, name: &str) -> Option<StructItem<'_>>

Get a struct by its name.

pub fn get_enum(&self, name: &str) -> Option<EnumItem<'_>>

Get an enum by its name.

pub fn get_trait(&self, name: &str) -> Option<TraitItem<'_>>

Get a trait by its name.

pub fn get_type_alias(&self, name: &str) -> Option<TypeAliasItem<'_>>

Get a type alias by its name.

pub fn get_trait_alias(&self, name: &str) -> Option<TraitAliasItem<'_>>

Get a trait alias by its name.

pub fn get_union(&self, name: &str) -> Option<UnionItem<'_>>

Get a union by its name.

pub fn get_module(&self, name: &str) -> Option<ModuleItem<'_>>

Get a module by its name.

Trait Implementations

impl<'a> Clone for ModuleItem<'a>

fn clone(&self) -> ModuleItem<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> CrateItem<'a> for ModuleItem<'a>

type Inner = Module

fn downcast(inner: &'a ItemEnum) -> Option<&'a Self::Inner>

fn new(krate: &'a Crate, item: &'a Item, module: &'a Self::Inner) -> Self

fn item(&self) -> &'a Item

fn inner(&self) -> &'a Self::Inner

fn krate(&self) -> &'a Crate

fn is_public(&self) -> bool

fn is_crate_item(&self) -> bool

fn is_root_item(&self) -> bool

fn is_external_item(&self) -> bool

fn id(&'a self) -> &'a Id

fn module(&self) -> Option<ModuleItem<'a>>

impl<'a> Debug for ModuleItem<'a>

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

Formats the value using the given formatter.

impl HasName for ModuleItem<'_>

fn name(&self) -> &str

impl<'a> PartialEq for ModuleItem<'a>

fn eq(&self, other: &ModuleItem<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Copy for ModuleItem<'a>

impl<'a> Eq for ModuleItem<'a>

impl<'a> StructuralPartialEq for ModuleItem<'a>