Struct Guard 

pub struct Guard<T, F>
where
    F: FnOnce(T),
{ /* private fields */ }

Generic RAII guard that owns a resource and cleans it up on drop

This is the fundamental building block for all RAII patterns in the project. It ensures that resources are properly cleaned up even if panics occur.

Type Parameters

• T: The type of resource being managed
• F: The type of cleanup function (must be FnOnce(T))

Example

use foundation_utils::raii::Guard;

let _guard = Guard::new(42, |value| {
    println!("Cleaning up value: {}", value);
});
// Cleanup happens automatically when guard drops

Implementations

impl<T, F> Guard<T, F>

where F: FnOnce(T),

pub fn new(resource: T, cleanup: F) -> Self

Create a new RAII guard

Arguments

• resource: The resource to manage
• cleanup: Function to call when the guard drops

Example

use foundation_utils::raii::Guard;

let guard = Guard::new("resource", |r| println!("Cleanup: {}", r));

pub fn resource(&self) -> &T

Get a reference to the managed resource

Panics

Panics if the guard has already been consumed (should not happen in normal use)

pub fn resource_mut(&mut self) -> &mut T

Get a mutable reference to the managed resource

Panics

Panics if the guard has already been consumed (should not happen in normal use)

pub fn into_inner(self) -> T

Consume the guard and return the resource without cleanup

This is useful when you want to transfer ownership without cleanup

pub fn cleanup_now(self)

Manually trigger cleanup now (guard becomes invalid after this)

This allows explicit cleanup before the guard would naturally drop

Trait Implementations

impl<T, F> Debug for Guard<T, F>

where T: Debug, F: FnOnce(T),

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

Formats the value using the given formatter.

impl<T, F> Drop for Guard<T, F>

where F: FnOnce(T),

fn drop(&mut self)

Executes the destructor for this type.