Struct abi_stable::external_types::parking_lot::once::ROnce

#[repr(C)]pub struct ROnce { /* fields omitted */ }

A synchronization primitive for running global initialization once.

Example

use abi_stable::external_types::{ROnce,RMutex};

static MUTEX:RMutex<usize>=RMutex::new(0);

static ONCE:ROnce=ROnce::new();

let guards=
    std::iter::repeat_with(||{
        std::thread::spawn(||{
            ONCE.call_once(||{
                *MUTEX.lock()+=1;
            })
        })
    })
    .take(20)
    .collect::<Vec<_>>();

for guard in guards{
    guard.join().unwrap();
}

assert_eq!(*MUTEX.lock(),1);

Implementations

impl ROnce

pub const fn new() -> ROnce

Constructs an ROnce.

Example

use abi_stable::external_types::ROnce;

static ONCE: ROnce = ROnce::new();
 

pub const NEW: Self

Constructs an ROnce.

Example

use abi_stable::external_types::ROnce;

static ONCE:ROnce=ROnce::NEW;

pub fn state(&self) -> ROnceState

Gets the running state of this ROnce.

Example

use abi_stable::external_types::parking_lot::once::{ROnce,ROnceState};

use std::panic::AssertUnwindSafe;

let once=ROnce::new();

assert_eq!(once.state(), ROnceState::New );

let _=std::panic::catch_unwind(AssertUnwindSafe(||{
    once.call_once(|| panic!() );
}));

assert!( once.state().poisoned() );

once.call_once_force(|_| () );

assert!( once.state().done() );

pub fn call_once<F>(&self, f: F) where
    F: FnOnce(), 

Runs an initialization function.

f will be run only if this is the first time this method has been called on this ROnce.

Once this function returns it is guaranteed that some closure passed to this method has run to completion.

Panics

Panics in the closure will cause this ROnce to become poisoned, and any future calls to this method will panic.

Example

use abi_stable::external_types::ROnce;

let once=ROnce::new();
let mut counter=0usize;

once.call_once(|| counter+=1 );
once.call_once(|| counter+=1 );
once.call_once(|| counter+=1 );
once.call_once(|| counter+=1 );

assert_eq!(counter,1);

pub fn call_once_force<F>(&self, f: F) where
    F: FnOnce(ROnceState), 

Runs an initialization function,even if the ROnce is poisoned.

This will keep trying to run different closures until one of them doesn't panic.

The ROnceState parameter describes whether the ROnce is New or Poisoned.

Example

use abi_stable::external_types::ROnce;

use std::panic::{self,AssertUnwindSafe};

let once=ROnce::new();
let mut counter=0usize;

for i in 0..100 {
    let _=panic::catch_unwind(AssertUnwindSafe(||{
        once.call_once_force(|_|{
            if i < 6 {
                panic!();
            }
            counter=i;
        })
    }));
}

assert_eq!(counter,6);

Trait Implementations

impl Debug for ROnce

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

Formats the value using the given formatter.

impl Default for ROnce

pub fn default() -> Self

Returns the "default value" for a type.

impl GetStaticEquivalent_ for ROnce

type StaticEquivalent = _static_ROnce

impl Send for ROnce

impl StableAbi for ROnce

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

impl Sync for ROnce