Struct rust_codegen::Trait

pub struct Trait { /* private fields */ }

Defines a trait.

Implementations

impl Trait

pub fn new(name: &str) -> Self

Return a trait definition with the provided name.

Arguments

• name - The name of the trait.

Examples

use rust_codegen::Trait;
 
let foo_trait = Trait::new("Foo");

pub fn ty(&self) -> &Type

Returns a reference to the type.

Examples

use rust_codegen::Trait;
 
let foo_trait = Trait::new("Foo");
println!("{:?}", foo_trait.ty());

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

Set the trait visibility.

Arguments

• vis - The visibility to set for the trait.

Examples

use rust_codegen::Trait;
 
let mut foo_trait = Trait::new("Foo");
foo_trait.vis("pub");

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

Add a generic to the trait.

Examples

use rust_codegen::Trait;
 
let mut foo_trait = Trait::new("Foo");
foo_trait.generic("T");

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

Add a where bound to the trait.

Arguments

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

Examples

use rust_codegen::Trait;
 
let mut foo_trait = Trait::new("Foo");
foo_trait.bound("A", "String");

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

Add a macro to the trait def (e.g. "#[async_trait]").

Arguments

• r#macro - The macro to add.

Examples

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

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

Add a parent trait.

Arguments

• ty - The type of the parent trait.

Examples

use rust_codegen::Trait;
 
let mut foo_trait = Trait::new("Foo");
foo_trait.parent("Bar");

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

Set the trait documentation.

Arguments

• docs - The documentation for the trait.

Examples

use rust_codegen::Trait;
 
let mut foo_trait = Trait::new("Foo");
foo_trait.doc("Sample trait documentation.");

pub fn associated_type(&mut self, name: &str) -> &mut AssociatedType

Add an associated type. Returns a mutable reference to the new associated type for futher configuration.

Arguments

• name - The name of the associated type.

Examples

use rust_codegen::Trait;
 
let mut foo_trait = Trait::new("Foo");
foo_trait.associated_type("A");

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::Trait;
 
let mut foo_trait = Trait::new("Foo");
foo_trait.new_fn("bar_fn");

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

Push a function definition.

Arguments

• item - The function to add.

Examples

use rust_codegen::{Function,Trait};
 
let mut foo_trait = Trait::new("Foo");
let mut bar_fn = Function::new("bar_fn");
 
foo_trait.push_fn(bar_fn);

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

Formats the scope using the given formatter.

Arguments

• fmt - The formatter to use.

Examples

use rust_codegen::{Formatter,Trait};
 
let mut dest = String::new();
let mut fmt = Formatter::new(&mut dest);
 
let mut foo_trait = Trait::new("Foo");
foo_trait.fmt(&mut fmt);

Trait Implementations

impl Clone for Trait

fn clone(&self) -> Trait

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Trait

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

Formats the value using the given formatter.