Struct function_wrapper::WrappedFn

pub struct WrappedFn {
    pub pre_code: Option<TokenStream>,
    pub function: ItemFn,
    pub wrapper_ident: Ident,
    pub result_ident: Ident,
    pub post_code: Option<TokenStream>,
}

Function that can have code inserted before and after the rest of the function executes. Can be constructed with syn::parse() and other variations of parsing from the syn crate.

Example:

let mut function = parse_macro_input!(token_stream as WrappedFn);

Code that runs before the function can be set using the set_pre_code() method.

Example:

function.set_pre_code(quote!{ println!("Hi at the start :)"); });

Code that runs after the function can be set using the set_post_code() method.

Example:

function.set_post_code(quote!{ println!("Hi at the end :)"); });

Fields

pre_code: Option<TokenStream>

Contains code that gets run before the rest of the function.

function: ItemFn

syn::ItemFn that contains all of the data of the original function, including the code inside, the function signature, any attributes, etc.

wrapper_ident: Ident

Identifier token for the closure that wraps all of the original code from the wrapped function. It is wrapper by default.

result_ident: Ident

Identifier token for the variable that holds the return value of the wrapped function. It is result by default.

post_code: Option<TokenStream>

Contains code that gets run after the rest of the function.

Implementations

impl WrappedFn

pub fn set_pre_code(&mut self, pre_code: TokenStream)

Sets the code that gets run before the rest of the function executes.

pub fn set_post_code(&mut self, post_code: TokenStream)

Sets the code that gets run after the rest of the function executes.

Trait Implementations

impl Clone for WrappedFn

fn clone(&self) -> WrappedFn

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<WrappedFn> for TokenStream

Allows WrappedFns to be converted into tokenstreams for easy use in procedural attribute macros.

fn from(function: WrappedFn) -> Self

Converts a WrappedFn into a proc_macro2::TokenStream.

impl Parse for WrappedFn

Main way to construct a WrappedFn. Can be constructed using syn::parse_macro_input like this:

let mut function = parse_macro_input!(token_stream as WrappedFn);

fn parse(input: ParseStream<'_>) -> Result<Self>

Constructs a WrappedFn from a syn::ParseStream.