Struct virtue::generate::ImplFor

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

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

Implementations

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

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

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;
}

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

Add a function to the trait implementation.

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

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

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

pub fn impl_type( &mut self, name: impl AsRef<str>, value: impl AsRef<str> ) -> Result

Add a type to the impl

generator.impl_for("Foo").impl_type("Bar", "u8") results in code like:

impl Foo for <struct or enum> {
    type Bar = u8;
}

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

where CB: FnOnce(&Generics, &mut GenericConstraints) -> Result,

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
    .impl_for("YourTrait")
    .modify_generic_constraints(|generics, constraints| {
        for g in generics.iter_generics() {
            constraints.push_generic(g, "YourTrait");
        }
    })

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

Trait Implementations

impl<P: Parent> Drop for ImplFor<'_, P>

fn drop(&mut self)

Executes the destructor for this type.