Struct HandlerGuard 

pub struct HandlerGuard<E: Send + Sync + 'static> { /* private fields */ }

Available on crate feature sync only.

RAII handle for a registered handler.

Drop the guard to unregister. Call HandlerGuard::forget to detach the guard from the handler, leaving the handler registered indefinitely.

The guard is not Clone; ownership of a registration is unique.

Examples

Automatic cleanup when the guard leaves scope:

use std::sync::Arc;
use registry_io::SyncRegistry;

let registry = Arc::new(SyncRegistry::<u32>::new());
assert_eq!(registry.handler_count(), 0);

{
    let _guard = registry.register_guard(|n| {
        println!("got {n}");
    });
    assert_eq!(registry.handler_count(), 1);
}

assert_eq!(registry.handler_count(), 0);

Forgetting the guard to keep the handler registered:

use std::sync::Arc;
use registry_io::SyncRegistry;

let registry = Arc::new(SyncRegistry::<()>::new());
let guard = registry.register_guard(|_| {});
let id = guard.id();
guard.forget();
// Handler is still active.
assert_eq!(registry.handler_count(), 1);
// Manually unregister via the returned id.
assert!(registry.unregister(id));

Implementations

impl<E: Send + Sync + 'static> HandlerGuard<E>

pub fn id(&self) -> HandlerId

Returns the HandlerId of the underlying registration.

Useful for diagnostic logging or to retain the id before consuming the guard with HandlerGuard::forget.

Examples

use std::sync::Arc;
use registry_io::SyncRegistry;

let registry = Arc::new(SyncRegistry::<()>::new());
let guard = registry.register_guard(|_| {});
let id = guard.id();
drop(guard);
// The id is still meaningful for logging, but the handler is gone:
assert!(!registry.contains(id));

pub fn forget(self)

Consume the guard without unregistering the handler.

The handler remains registered until it is explicitly removed via SyncRegistry::unregister or the registry is dropped.

Examples

use std::sync::Arc;
use registry_io::SyncRegistry;

let registry = Arc::new(SyncRegistry::<()>::new());
let guard = registry.register_guard(|_| {});
guard.forget();
assert_eq!(registry.handler_count(), 1);

Trait Implementations

impl<E: Send + Sync + 'static> Debug for HandlerGuard<E>

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

Formats the value using the given formatter.

impl<E: Send + Sync + 'static> Drop for HandlerGuard<E>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.