Struct kernel::sync::StaticRef

pub struct StaticRef<T: ?Sized> { /* private fields */ }

Allows the creation of “reference-counted” globals.

This is achieved by biasing the refcount with +1, which ensures that the count never drops back to zero (unless buggy unsafe code incorrectly decrements without owning an increment) and therefore also ensures that drop is never called.

Examples

use kernel::sync::{Ref, RefBorrow, StaticRef};

const VALUE: u32 = 10;
static SR: StaticRef<u32> = StaticRef::new(VALUE);

fn takes_ref_borrow(v: RefBorrow<'_, u32>) {
    assert_eq!(*v, VALUE);
}

fn takes_ref(v: Ref<u32>) {
    assert_eq!(*v, VALUE);
}

takes_ref_borrow(SR.as_ref_borrow());
takes_ref(SR.as_ref_borrow().into());

Implementations

impl<T> StaticRef<T>

pub const fn new(data: T) -> Self

Creates a new instance of a static “ref-counted” object.

impl<T: ?Sized> StaticRef<T>

pub fn as_ref_borrow(&'static self) -> RefBorrow<'static, T>

Creates a RefBorrow instance from the given static object.

This requires a 'static lifetime so that it can guarantee that the underlyling object remains valid and is effectively pinned.

Trait Implementations

impl<T: ?Sized + Sync + Send> Sync for StaticRef<T>