Struct rust_codegen::Impl

pub struct Impl { /* private fields */ }

Defines an impl block.

Implementations

impl Impl

pub fn new<T>(target: T) -> Self where
    T: Into<Type>, 

Returns a new impl definition.

Arguments

• target - The impl’s target.

Examples

use rust_codegen::Impl;
 
let foo_impl = Impl::new("Foo");

pub fn generic(&mut self, name: &str) -> &mut Self

Add a generic to the impl block.

This adds the generic for the block (impl<T>) and not the target type.

Arguments

• name - The name of the generic.

Examples

use rust_codegen::Impl;
 
let mut foo_impl = Impl::new("Foo");
foo_impl.generic("T");

pub fn target_generic<T>(&mut self, ty: T) -> &mut Self where
    T: Into<Type>, 

Add a generic to the target type.

Arguments

• ty - The generic type to add to the target.

Examples

use rust_codegen::Impl;
 
let mut foo_impl = Impl::new("Foo");
foo_impl.target_generic("T");

pub fn impl_trait<T>(&mut self, ty: T) -> &mut Self where
    T: Into<Type>, 

Set the trait that the impl block is implementing.

Arguments

• ty - The trait that the impl block is implementing.

Examples

use rust_codegen::Impl;
 
let mut foo_impl = Impl::new("Foo");
foo_impl.impl_trait("T");

pub fn macro(&mut self, macro: &str) -> &mut Self

Add a macro to the impl block (e.g. "#[async_trait]")

Arguments

• macro - The macro to add.

Examples

use rust_codegen::Impl;
 
let mut foo_impl = Impl::new("Foo");
foo_impl.r#macro("async_trait");

pub fn associate_type<T>(&mut self, name: &str, ty: T) -> &mut Self where
    T: Into<Type>, 

Set an associated type.

Arguments

• name - The name of the associated type.
• ty - The type of the associated type.

Examples

use rust_codegen::*;
 
let mut scope = Scope::new();
 
let trait_foo = scope.new_trait("Foo");
let mut impl_bar = Impl::new("Bar");
 
impl_bar.associate_type("A", "Foo");

pub fn bound<T>(&mut self, name: &str, ty: T) -> &mut Self where
    T: Into<Type>, 

Add a where bound to the impl block.

Arguments

• name - The name of the bound.
• ty - The type of the bound.

Examples

use rust_codegen::Impl;
 
let mut foo_impl = Impl::new("Foo");
foo_impl.bound("T", "Default");

pub fn new_fn(&mut self, name: &str) -> &mut Function

Push a new function definition, returning a mutable reference to it.

Arguments

• name - The name of the function.

Examples

use rust_codegen::Impl;
 
let mut foo_impl = Impl::new("Foo");
foo_impl.new_fn("bar_fn");

pub fn push_fn(&mut self, item: Function) -> &mut Self

Push a function definition.

Arguments

• item - The function definition to push.

Examples

use rust_codegen::{Function,Impl};
 
let mut foo_impl = Impl::new("Foo");
let bar_fn = Function::new("bar");
 
foo_impl.push_fn(bar_fn);

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

Formats the impl block using the given formatter.

Arguments

• fmt - The formatter to use.

Examples

use rust_codegen::*;
 
let mut dest = String::new();
let mut fmt = Formatter::new(&mut dest);
 
let mut foo_impl = Impl::new("Foo");
foo_impl.fmt( &mut fmt);

Trait Implementations

impl Clone for Impl

fn clone(&self) -> Impl

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Impl

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

Formats the value using the given formatter.