Struct devise::DeriveGenerator

pub struct DeriveGenerator {
    pub input: ItemInput,
    pub item: TraitItem,
    pub support: Support,
    pub validator: Option<Box<dyn Validator, Global>>,
    pub inner_mappers: Vec<Box<dyn Mapper, Global>, Global>,
    pub outer_mappers: Vec<Box<dyn Mapper, Global>, Global>,
    pub type_bound_mapper: Option<Box<dyn Mapper, Global>>,
    /* private fields */
}

Fields

input: ItemInput

item: TraitItem

support: Support

validator: Option<Box<dyn Validator, Global>>

inner_mappers: Vec<Box<dyn Mapper, Global>, Global>

outer_mappers: Vec<Box<dyn Mapper, Global>, Global>

type_bound_mapper: Option<Box<dyn Mapper, Global>>

Implementations

impl DeriveGenerator

pub fn build_for<I, T>(input: I, trait_impl: T) -> DeriveGeneratorwhere I: Into<TokenStream>, T: ToTokens,

pub fn support(&mut self, support: Support) -> &mut DeriveGenerator

pub fn type_bound<B>(&mut self, bound: B) -> &mut DeriveGeneratorwhere B: ToTokens,

pub fn replace_generic( &mut self, trait_gen: usize, impl_gen: usize ) -> &mut DeriveGenerator

Take the 0-indexed trait_genth generic in the generics in impl<..> being built and substitute those tokens in place of the 0-indexed impl_genth generic of the same kind in the input type.

pub fn validator<V>(&mut self, validator: V) -> &mut DeriveGeneratorwhere V: Validator + 'static,

pub fn type_bound_mapper<V>(&mut self, mapper: V) -> &mut DeriveGeneratorwhere V: Mapper + 'static,

pub fn inner_mapper<V>(&mut self, mapper: V) -> &mut DeriveGeneratorwhere V: Mapper + 'static,

pub fn outer_mapper<V>(&mut self, mapper: V) -> &mut DeriveGeneratorwhere V: Mapper + 'static,

pub fn debug(&mut self) -> &mut DeriveGenerator

pub fn to_tokens<T>(&mut self) -> Twhere T: From<TokenStream>,

pub fn try_to_tokens<T>(&mut self) -> Result<T, Diagnostic>where T: From<TokenStream>,