Struct DeriveGenerator

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

Fields

input: ItemInput

item: TraitItem

support: Support

validator: Option<Box<dyn Validator>>

inner_mappers: Vec<Box<dyn Mapper>>

outer_mappers: Vec<Box<dyn Mapper>>

type_bound_mapper: Option<Box<dyn Mapper>>

Implementations

impl DeriveGenerator

pub fn build_for<I, T>(input: I, trait_impl: T) -> DeriveGenerator

where I: Into<TokenStream>, T: ToTokens,

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

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

where 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 DeriveGenerator

where V: Validator + 'static,

pub fn type_bound_mapper<V>(&mut self, mapper: V) -> &mut DeriveGenerator

where V: Mapper + 'static,

pub fn inner_mapper<V>(&mut self, mapper: V) -> &mut DeriveGenerator

where V: Mapper + 'static,

pub fn outer_mapper<V>(&mut self, mapper: V) -> &mut DeriveGenerator

where V: Mapper + 'static,

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

pub fn to_tokens<T>(&mut self) -> T

where T: From<TokenStream>,

pub fn try_to_tokens<T>(&mut self) -> Result<T, Diagnostic>

where T: From<TokenStream>,