Struct StructItem

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

Implementations

impl<'a> StructItem<'a>

pub fn name(&self) -> &str

Examples found in repository

examples/downcast.rs (line 11)

fn main() {
    use crate_inspector::{CrateBuilder, StructItem};

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

    for item in krate.items() {
        if let Some(strc) = krate.downcast::<StructItem>(item) {
            println!("struct: {}", strc.name());
        }
    }
}

examples/items.rs (line 13)

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 field_ids(&self) -> Option<impl Iterator<Item = &Id>>

pub fn fields(&self) -> Option<impl Iterator<Item = FieldItem<'_>>>

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

Examples found in repository

examples/items.rs (line 14)

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 trait_impls(&self) -> impl Iterator<Item = ImplItem<'_>>

Iterate over struct impls that are trait impls (impl <Trait> for <Struct> { ... }). These may include auto/blanket impls.

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

Iterate over struct blanket impls (impl<T: ...> <Trait> for <Struct<T>> { ... }).

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

Iterate over struct non-blanket impls (impl <Trait> for <Struct> { ... }).

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

Iterator over struct impls that are not trait impls.

Trait Implementations

impl<'a> Clone for StructItem<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> CrateItem<'a> for StructItem<'a>

type Inner = Struct

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

fn new(krate: &'a Crate, item: &'a Item, struct_: &'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 StructItem<'a>

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

Formats the value using the given formatter.

impl HasName for StructItem<'_>

fn name(&self) -> &str

impl<'a> PartialEq for StructItem<'a>

fn eq(&self, other: &StructItem<'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 StructItem<'a>

impl<'a> Eq for StructItem<'a>

impl<'a> StructuralPartialEq for StructItem<'a>