Struct ManuallyStatic

pub struct ManuallyStatic<T> { /* private fields */ }

ManuallyStatic<T> holds a value T and provides references to it with checking with debug_assertions.

In debug builds, it tracks if the original ManuallyStatic instance has been dropped, causing any derived ManuallyStaticRef to panic upon dereference if the original owner is no longer alive.

This is useful for simulating a ’static lifetime where you want runtime checks for use-after-free in debug environments.

Example

use manually_static::ManuallyStatic;
use std::thread;
use std::time::Duration;

struct AppConfig {
    version: String,
}

let config = ManuallyStatic::new(AppConfig {
    version: String::from("1.0.0"),
});

// Get a 'static reference to the config.
// This is where ManuallyStatic shines, allowing us to pass
// a reference that the compiler would normally complain about
// without complex ownership transfers or Arc for simple reads.
let config_ref = config.get_ref();

let handle = thread::spawn(move || {
    // In this thread, we can safely access the config via the 'static reference.
    // In debug builds, if `config` (the original ManuallyStatic) was dropped
    // before this thread accessed it, it would panic.

    thread::sleep(Duration::from_millis(100)); // Simulate some work

    println!("Thread: App Version: {}", config_ref.version);
});

handle.join().unwrap();

// config is dropped here after the thread has finished

Implementations

impl<T> ManuallyStatic<T>

pub fn new(value: T) -> Self

Creates a new ManuallyStatic instance holding the given value.

pub fn get_ref(&self) -> ManuallyStaticRef<T>

Returns a ManuallyStaticRef that provides immutable access to the contained value. In debug builds, dereferencing this will panic if the original ManuallyStatic instance has been dropped.

Trait Implementations

impl<T> Drop for ManuallyStatic<T>

Implements the Drop trait for ManuallyStatic<T> only in debug builds. When ManuallyStatic is dropped, it sets the was_dropped flag to true.

fn drop(&mut self)

Executes the destructor for this type.