// Copyright 2019 Developers of the Rand project.

//

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license

// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your

// option. This file may not be copied, modified, or distributed

// except according to those terms.

#![allow(dead_code)]

use core::{

    mem::MaybeUninit,

    ptr,

    sync::atomic::{AtomicUsize, Ordering::Relaxed},

};

// This structure represents a lazily initialized static usize value. Useful

// when it is preferable to just rerun initialization instead of locking.

// Both unsync_init and sync_init will invoke an init() function until it

// succeeds, then return the cached value for future calls.

//

// Both methods support init() "failing". If the init() method returns UNINIT,

// that value will be returned as normal, but will not be cached.

//

// Users should only depend on the _value_ returned by init() functions.

// Specifically, for the following init() function:

//      fn init() -> usize {

//          a();

//          let v = b();

//          c();

//          v

//      }

// the effects of c() or writes to shared memory will not necessarily be

// observed and additional synchronization methods with be needed.

pub struct LazyUsize(AtomicUsize);

impl LazyUsize {

    pub const fn new() -> Self {

        Self(AtomicUsize::new(Self::UNINIT))

    }

    // The initialization is not completed.

    pub const UNINIT: usize = usize::max_value();

    // Runs the init() function at least once, returning the value of some run

    // of init(). Multiple callers can run their init() functions in parallel.

    // init() should always return the same value, if it succeeds.

    pub fn unsync_init(&self, init: impl FnOnce() -> usize) -> usize {

        // Relaxed ordering is fine, as we only have a single atomic variable.

        let mut val = self.0.load(Relaxed);

        if val == Self::UNINIT {

            val = init();

            self.0.store(val, Relaxed);

        }

        val

    }

}

// Identical to LazyUsize except with bool instead of usize.

pub struct LazyBool(LazyUsize);

impl LazyBool {

    pub const fn new() -> Self {

        Self(LazyUsize::new())

    }

    pub fn unsync_init(&self, init: impl FnOnce() -> bool) -> bool {

        self.0.unsync_init(|| init() as usize) != 0

    }

}

/// Polyfill for `maybe_uninit_slice` feature's

/// `MaybeUninit::slice_assume_init_mut`. Every element of `slice` must have

/// been initialized.

#[inline(always)]

pub unsafe fn slice_assume_init_mut<T>(slice: &mut [MaybeUninit<T>]) -> &mut [T] {

    // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.

    &mut *(slice as *mut [MaybeUninit<T>] as *mut [T])

}

Unexecuted instantiation: getrandom::util::slice_assume_init_mut::<u8>

Unexecuted instantiation: getrandom::util::slice_assume_init_mut::<_>

#[inline]

pub fn uninit_slice_fill_zero(slice: &mut [MaybeUninit<u8>]) -> &mut [u8] {

    unsafe { ptr::write_bytes(slice.as_mut_ptr(), 0, slice.len()) };

    unsafe { slice_assume_init_mut(slice) }

}

#[inline(always)]

pub fn slice_as_uninit<T>(slice: &[T]) -> &[MaybeUninit<T>] {

    // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.

    // There is no risk of writing a `MaybeUninit<T>` into the result since

    // the result isn't mutable.

    unsafe { &*(slice as *const [T] as *const [MaybeUninit<T>]) }

}

/// View an mutable initialized array as potentially-uninitialized.

///

/// This is unsafe because it allows assigning uninitialized values into

/// `slice`, which would be undefined behavior.

#[inline(always)]

pub unsafe fn slice_as_uninit_mut<T>(slice: &mut [T]) -> &mut [MaybeUninit<T>] {

    // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.

    &mut *(slice as *mut [T] as *mut [MaybeUninit<T>])

}

Unexecuted instantiation: getrandom::util::slice_as_uninit_mut::<u8>

Unexecuted instantiation: getrandom::util::slice_as_uninit_mut::<_>