Struct Impl

pub struct Impl<'a, P: Parent> { /* private fields */ }

A helper struct for implementing functions for a given struct or enum.

Implementations

impl<'a, P: Parent> Impl<'a, P>

pub fn impl_outer_attr(&mut self, attr: impl AsRef<str>) -> Result

Add a outer attribute to the trait implementation

pub fn impl_inner_attr(&mut self, attr: impl AsRef<str>) -> Result

Add a inner attribute to the trait implementation

pub fn generate_fn(&mut self, name: impl Into<String>) -> FnBuilder<'_, Self>

Add a function to the trait implementation.

generator.impl().generate_fn("bar") results in code like:

impl <struct or enum> {
    fn bar() {}
}

See FnBuilder for more options, as well as information on how to fill the function body.

pub fn generate_const( &mut self, name: impl Into<String>, ty: impl Into<String>, ) -> GenConst<'_>

Add a const to the trait implementation

generator.impl_for("Foo")
         .generate_const("BAR", "u8")
         .with_value(|b| {
            b.push_parsed("5")?;
            Ok(())
         })?;

Generates:

impl Foo for <struct or enum> {
    const BAR: u8 = 5;
}

impl<'a> Impl<'a, Generator>

pub fn modify_generic_constraints<CB>(&mut self, cb: CB) -> &mut Self

where CB: FnOnce(&Generics, &mut GenericConstraints),

Modify the generic constraints of a type. This can be used to add additional type constraints to your implementation.

// Your derive:
#[derive(YourTrait)]
pub struct Foo<B> {
    ...
}

// With this code:
generator
    .r#impl()
    .modify_generic_constraints(|generics, constraints| {
        for g in generics.iter_generics() {
            constraints.push_generic(g, "YourTrait");
        }
    })

// will generate:
impl<B> Foo<B>
    where B: YourTrait // <-
{
}

Note that this function is only implemented when you call .r#impl on Generator.

Trait Implementations

impl<'a, P: Parent> Drop for Impl<'a, P>

fn drop(&mut self)

Executes the destructor for this type.