Struct devise::DeriveGenerator

pub struct DeriveGenerator {
    pub input: DeriveInput,
    pub trait_impl: ItemImpl,
    pub trait_path: Path,
    // some fields omitted
}

Fields

input: DeriveInput

trait_impl: ItemImpl

trait_path: Path

Methods

impl DeriveGenerator

pub fn build_for(input: TokenStream, trait_impl: TokenStream) -> DeriveGenerator

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

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

pub fn map_type_generic<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, &Ident, &TypeParam) -> TokenStream, 

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

pub fn validate_enum<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<DataEnum>) -> Result<(), Diagnostic>, 

pub fn validate_struct<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<DataStruct>) -> Result<(), Diagnostic>, 

pub fn validate_generics<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, &Generics) -> Result<(), Diagnostic>, 

pub fn validate_fields<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Fields) -> Result<(), Diagnostic>, 

pub fn function<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, TokenStream) -> TokenStream, 

pub fn map_struct<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<DataStruct>) -> TokenStream, 

pub fn try_map_struct<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<DataStruct>) -> Result<TokenStream, Diagnostic>, 

pub fn struct_mapper(
    &self
) -> &Box<dyn Fn(&DeriveGenerator, Derived<DataStruct>) + 'static>

pub fn map_enum<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<DataEnum>) -> TokenStream, 

pub fn try_map_enum<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<DataEnum>) -> Result<TokenStream, Diagnostic>, 

pub fn enum_mapper(
    &self
) -> &Box<dyn Fn(&DeriveGenerator, Derived<DataEnum>) + 'static>

pub fn map_variant<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<Variant>) -> TokenStream, 

pub fn try_map_variant<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Derived<Variant>) -> Result<TokenStream, Diagnostic>, 

pub fn variant_mapper(
    &self
) -> &Box<dyn Fn(&DeriveGenerator, Derived<Variant>) + 'static>

pub fn map_fields<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Fields) -> TokenStream, 

pub fn try_map_fields<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Fields) -> Result<TokenStream, Diagnostic>, 

pub fn fields_mapper(&self) -> &Box<dyn Fn(&DeriveGenerator, Fields) + 'static>

pub fn map_field<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Field) -> TokenStream, 

pub fn try_map_field<F>(&mut self, f: F) -> &mut DeriveGenerator where
    F: 'static + Fn(&DeriveGenerator, Field) -> Result<TokenStream, Diagnostic>, 

pub fn field_mapper(&self) -> &Box<dyn Fn(&DeriveGenerator, Field) + 'static>

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

pub fn to_tokens(&mut self) -> TokenStream