Struct ProceedingJoinPoint 

pub struct ProceedingJoinPoint<'a> { /* private fields */ }

A proceeding joinpoint that can be used in “around” advice.

This type wraps the original function execution and allows aspects to control when (or if) the function runs.

Example

use aspect_core::prelude::*;
use std::any::Any;

struct TimingAspect;

impl Aspect for TimingAspect {
    fn around(&self, pjp: ProceedingJoinPoint) -> Result<Box<dyn Any>, AspectError> {
        let start = std::time::Instant::now();
        let result = pjp.proceed()?;
        let elapsed = start.elapsed();
        println!("Execution took: {:?}", elapsed);
        Ok(result)
    }
}

Implementations

impl<'a> ProceedingJoinPoint<'a>

pub fn new<F>(f: F, context: JoinPoint) -> Self

where F: FnOnce() -> Result<Box<dyn Any>, AspectError> + 'a,

Creates a new ProceedingJoinPoint.

Parameters

• f: The original function to execute
• context: Information about the joinpoint

pub fn proceed(self) -> Result<Box<dyn Any>, AspectError>

Proceeds with the original function execution.

This consumes the ProceedingJoinPoint and executes the wrapped function.

Returns

The result of the function execution.

Example

fn around(&self, pjp: ProceedingJoinPoint) -> Result<Box<dyn Any>, AspectError> {
    println!("Before proceed");
    let result = pjp.proceed()?;
    println!("After proceed");
    Ok(result)
}

pub fn context(&self) -> &JoinPoint

Returns a reference to the joinpoint context.

Example

fn around(&self, pjp: ProceedingJoinPoint) -> Result<Box<dyn Any>, AspectError> {
    let ctx = pjp.context();
    println!("Calling: {}", ctx.function_name);
    pjp.proceed()
}

Trait Implementations

impl<'a> Debug for ProceedingJoinPoint<'a>

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

Formats the value using the given formatter.